def _gpfs_ssh_execute(self, ssh, cmd, ignore_exit_code=None, check_exit_code=True): sanitized_cmd = strutils.mask_password(cmd) LOG.debug('Running cmd (SSH): %s', sanitized_cmd) stdin_stream, stdout_stream, stderr_stream = ssh.exec_command(cmd) channel = stdout_stream.channel stdout = stdout_stream.read() sanitized_stdout = strutils.mask_password(stdout) stderr = stderr_stream.read() sanitized_stderr = strutils.mask_password(stderr) stdin_stream.close() exit_status = channel.recv_exit_status() # exit_status == -1 if no exit code was returned if exit_status != -1: LOG.debug('Result was %s' % exit_status) if ((check_exit_code and exit_status != 0) and (ignore_exit_code is None or exit_status not in ignore_exit_code)): raise exception.ProcessExecutionError(exit_code=exit_status, stdout=sanitized_stdout, stderr=sanitized_stderr, cmd=sanitized_cmd) return (sanitized_stdout, sanitized_stderr)
def _execute(self, *cmd, **kwargs): for x in range(0, len(self.hosts)): try: check_exit_code = kwargs.pop('check_exit_code', True) host = self.hosts[x] if host in self.local_hosts: cmd = self._as_user(cmd, self.configuration.maprfs_ssh_name) out, err = utils.execute(*cmd, check_exit_code=check_exit_code) else: out, err = self._run_ssh(host, cmd, check_exit_code) # move available cldb host to the beginning if x > 0: self.hosts[0], self.hosts[x] = self.hosts[x], self.hosts[0] return out, err except exception.ProcessExecutionError as e: if self._check_error(e): raise elif x < len(self.hosts) - 1: msg = ('Error running SSH command. Trying another host') LOG.error(msg) else: raise except Exception as e: if x < len(self.hosts) - 1: msg = ('Error running SSH command. Trying another host') LOG.error(msg) else: raise exception.ProcessExecutionError(six.text_type(e))
def _get_gluster_vol_option(opt): if opt == 'auth.ssl-allow': return('some.common.name,' + access['access_to']) elif opt == 'dynamic-auth': if falseish == '!': raise exception.ProcessExecutionError(exit_code=1) return falseish
def delete_volume(self, name): cmd = [self.maprcli_bin, 'volume', 'remove', '-name', name, '-force', 'true'] out, __ = self._execute(*cmd, check_exit_code=False) # if volume does not exist do not raise exception.ProcessExecutionError if self.ERROR_MSG in out and self.NOT_FOUND_MSG not in out: raise exception.ProcessExecutionError(out)
def delete_snapshot(self, name, volume_name): cmd = [self.maprcli_bin, 'volume', 'snapshot', 'remove', '-snapshotname', name, '-volume', volume_name] out, __ = self._execute(*cmd, check_exit_code=False) # if snapshot does not exist do not raise ProcessExecutionError if self.ERROR_MSG in out and self.NOT_FOUND_MSG not in out: raise exception.ProcessExecutionError(out)
def get_cluster_name(self): cmd = [self.maprcli_bin, 'dashboard', 'info', '-json'] out, __ = self._execute(*cmd) try: return json.loads(out)['data'][0]['cluster']['name'] except (IndexError, ValueError) as e: msg = (_("Failed to parse cluster name. Error: %s") % e) raise exception.ProcessExecutionError(msg)
def fake_ovs_execute(*args, **kwargs): if len(args) == 3: return list_of_veths if len(args) == 4: return ('fake:manila_b5afb5c1_6011_43c4_8a37_29820e6951a7', '') if 'del-port' in args: raise exception.ProcessExecutionError() else: return 0
def test_is_kernel_version_false(self): zfs_utils.utils.execute.reset_mock() zfs_utils.utils.execute.side_effect = ( exception.ProcessExecutionError('Fake')) self.assertFalse(self.helper.is_kernel_version) zfs_utils.utils.execute.assert_has_calls([ mock.call("modinfo", "zfs"), ])
def test_get_valid_users_not_force_with_exc(self): self.mock_object( self._helper, '_ssh_exec', mock.Mock(side_effect=exception.ProcessExecutionError())) self.assertRaises(exception.ProcessExecutionError, self._helper._get_valid_users, self.server_details, self.share_name, const.ACCESS_LEVEL_RW, force=False) self._helper._ssh_exec.assert_called_once_with( self.server_details, ['sudo', 'net', 'conf', 'getparm', self.share_name, 'valid users'])
def test_create_export_share_does_not_exist_exception(self): self.mock_object( self._helper, '_ssh_exec', mock.Mock( side_effect=[exception.ProcessExecutionError(), Exception('')])) self.assertRaises(exception.ManilaException, self._helper.create_exports, self.server_details, self.share_name)
def test_execute_with_retry(self): self.mock_object(time, 'sleep') self.mock_object( self.driver, 'execute', mock.Mock( side_effect=[exception.ProcessExecutionError('FAKE'), None])) self.driver.execute_with_retry('foo', 'bar') self.assertEqual(2, self.driver.execute.call_count) self.driver.execute.assert_has_calls( [mock.call('foo', 'bar'), mock.call('foo', 'bar')])
def test_set_vol_option_error_relaxed(self): fake_obj = mock.Mock( side_effect=exception.ProcessExecutionError(exit_code=1)) with mock.patch.object(common.ganesha_utils, 'RootExecutor', mock.Mock(return_value=fake_obj)): gluster_manager = common.GlusterManager( '127.0.0.1:/testvol', self.fake_execf) gluster_manager.set_vol_option('an_option', "some_value", ignore_failure=True) self.assertTrue(fake_obj.called)
def test_set_vol_option_error(self, kwargs): fake_obj = mock.Mock( side_effect=exception.ProcessExecutionError(exit_code=1)) with mock.patch.object(common.ganesha_utils, 'RootExecutor', mock.Mock(return_value=fake_obj)): gluster_manager = common.GlusterManager( '127.0.0.1:/testvol', self.fake_execf) self.assertRaises(exception.GlusterfsException, gluster_manager.set_vol_option, 'an_option', "some_value", **kwargs) self.assertTrue(fake_obj.called)
def test__unmount_device_with_retry_busy_device(self, retry_busy_device): execute_sideeffects = [ exception.ProcessExecutionError(stderr='device is busy'), exception.ProcessExecutionError( stderr='target is busy'), None, None ] if retry_busy_device else [None, None] mount_path = self._get_mount_path(self.share) self._os.path.exists.return_value = True self.mock_object(self._driver, '_execute', mock.Mock(side_effect=execute_sideeffects)) self._driver._unmount_device(self.share, retry_busy_device=retry_busy_device) num_of_times_umount_is_called = 3 if retry_busy_device else 1 self._os.path.exists.assert_called_with(mount_path) self._driver._execute.assert_has_calls( [ mock.call('umount', '-f', mount_path, run_as_root=True), ] * num_of_times_umount_is_called + [mock.call('rmdir', mount_path, run_as_root=True)])
def fs_capacity(self): cmd = [self.hadoop_bin, 'fs', '-df'] out, err = self._execute(*cmd) lines = out.splitlines() try: fields = lines[1].split() total = int(fields[1]) free = int(fields[3]) except (IndexError, ValueError): msg = _('Failed to get MapR-FS capacity info.') LOG.exception(msg) raise exception.ProcessExecutionError(msg) return total, free
def test_init_helper_log(self): # mocks self.mock_object( self._helper, '_ssh_exec', mock.Mock(side_effect=exception.ProcessExecutionError( stderr='fake'))) # run self._helper.init_helper(self.server) # asserts self._helper._ssh_exec.assert_called_once_with(self.server, ['sudo', 'exportfs'])
def test_execute_with_retry_exceeded(self): self.mock_object(time, 'sleep') self.mock_object( self.driver, 'execute', mock.Mock(side_effect=exception.ProcessExecutionError('FAKE'))) self.assertRaises( exception.ProcessExecutionError, self.driver.execute_with_retry, 'foo', 'bar', ) self.assertEqual(36, self.driver.execute.call_count)
def test_deny_access_force(self): self.mock_object( self._helper, '_get_allow_hosts', mock.Mock(side_effect=exception.ProcessExecutionError()), ) self.mock_object(self._helper, '_set_allow_hosts') self._helper.deny_access( self.server_details, self.share_name, self.access, force=True) self._helper._get_allow_hosts.assert_called_once_with( self.server_details, self.share_name) self._helper._set_allow_hosts.assert_has_calls([])
def test_ldap_retry_operation_invalid_credential(self): mock_cmd = ["command", "to", "be", "executed"] mock_execute = self.mock_object( self.security_service_helper, '_execute', mock.Mock(side_effect=exception.ProcessExecutionError( exit_code=49))) self.assertRaises(exception.ShareBackendException, self.security_service_helper.ldap_retry_operation, mock_cmd, run_as_root=False) mock_execute.assert_called_once_with(*mock_cmd, run_as_root=False)
def test_verify_setup_error_calling_exportfs(self): zfs_utils.utils.execute.reset_mock() zfs_utils.utils.execute.side_effect = [ ('fake_out', ''), exception.ProcessExecutionError('Fake') ] self.assertRaises(exception.ProcessExecutionError, self.helper.verify_setup) zfs_utils.utils.execute.assert_has_calls([ mock.call("which", "exportfs"), mock.call("exportfs", run_as_root=True), ])
def try_ldap_operation(): try: self._execute(*cmd, run_as_root=run_as_root) except exception.ProcessExecutionError as e: if e.exit_code == LDAP_INVALID_CREDENTIALS: msg = _('LDAP credentials are invalid. ' 'Aborting operation.') LOG.warning(msg) raise exception.ShareBackendException(msg=msg) else: msg = _('Command has returned execution error.' ' Will retry the operation.' ' Error details: %s') % e.stderr LOG.warning(msg) raise exception.ProcessExecutionError()
def test_init_helper(self): # mocks self.mock_object( self._helper, '_ssh_exec', mock.Mock(side_effect=exception.ProcessExecutionError( stderr='command not found'))) # run self.assertRaises(exception.ManilaException, self._helper.init_helper, self.server) # asserts self._helper._ssh_exec.assert_called_once_with(self.server, ['sudo', 'exportfs'])
def test_update_access_exception(self): aces = { 'volumeAces': { 'readAce': 'p', 'writeAce': 'p', } } self._driver._maprfs_util.get_volume_info = mock.Mock( return_value=aces) self._driver._maprfs_util.group_exists = mock.Mock(return_value=True) utils.execute = mock.Mock(side_effect=exception.ProcessExecutionError( stdout='ERROR')) self.assertRaises(exception.MapRFSException, self._driver.update_access, self._context, self.share, [self.access], [], [])
def test_ldap_retry_operation_timeout(self): mock_cmd = ["command", "to", "be", "executed"] mock_execute = self.mock_object( self.security_service_helper, '_execute', mock.Mock(side_effect=exception.ProcessExecutionError( exit_code=1))) self.assertRaises(exception.ShareBackendException, self.security_service_helper.ldap_retry_operation, mock_cmd, run_as_root=False, timeout=10) mock_execute.assert_has_calls([ mock.call(*mock_cmd, run_as_root=False), mock.call(*mock_cmd, run_as_root=False) ])
def test_mount_device_exception_01(self): volume = {'mountpoint': 'fake_mount_point'} self._driver._ssh_exec.side_effect = [ exception.ProcessExecutionError(stderr='already mounted'), None ] self.stubs.Set(self._driver, '_get_mount_path', mock.Mock(return_value='fake_mount_path')) self._driver._mount_device(self._context, self.share, 'fake_server', volume) self._driver._ssh_exec.assert_has_calls([ mock.call('fake_server', [ 'sudo', 'mkdir', '-p', 'fake_mount_path', ';', 'sudo', 'mount', volume['mountpoint'], 'fake_mount_path' ]), mock.call('fake_server', ['sudo', 'chmod', '777', 'fake_mount_path']) ])
def test_deny_access_force_exc(self, access): self.mock_object( self._helper, '_get_valid_users', mock.Mock(side_effect=exception.ProcessExecutionError()), ) self.mock_object(self._helper, '_set_valid_users') self.assertRaises(exception.ProcessExecutionError, self._helper.deny_access, self.server_details, self.share_name, access, force=True) self._helper._get_valid_users.assert_called_once_with( self.server_details, self.share_name, access['access_level'], force=True)
def mock_return(*args, **kwargs): if args == test_args[0]: if mv_error: raise exception.ProcessExecutionError() else: return ('', '')
def raise_exception(*args, **kwargs): if(args == test_args): raise exception.ProcessExecutionError()
def fake_ssh_exec(*args, **kwargs): if delshare_command == args[1]: raise exception.ProcessExecutionError() else: return ('', '')
def fake_ssh_exec(*args, **kwargs): if 'showshare' in args[1]: raise exception.ProcessExecutionError() else: return '', ''