docs: def __call(self, *args, **kwargs):
          '''
          Call Zypper.
  
          :param state:
          :return:
          '''
          self.__called = True
          if self.__xml:
              self.__cmd.append('--xmlout')
          if not self.__refresh and '--no-refresh' not in args:
              self.__cmd.append('--no-refresh')
          if self.__root:
              self.__cmd.extend(['--root', self.__root])
  
          self.__cmd.extend(args)
          kwargs['output_loglevel'] = 'trace'
          kwargs['python_shell'] = False
          kwargs['env'] = self.__env.copy()
          if self.__no_lock:
              kwargs['env']['ZYPP_READONLY_HACK'] = "1"  # Disables locking for read-only operations. Do not try that at home!
  
          # Zypper call will stuck here waiting, if another zypper hangs until forever.
          # However, Zypper lock needs to be always respected.
          was_blocked = False
          while True:
              cmd = []
              if self.__systemd_scope:
                  cmd.extend(['systemd-run', '--scope'])
              cmd.extend(self.__cmd)
              log.debug('Calling Zypper: %s', ' '.join(cmd))
              self.__call_result = __salt__['cmd.run_all'](cmd, **kwargs)
              if self._check_result():
                  break
  
              if os.path.exists(self.ZYPPER_LOCK):
                  try:
                      with salt.utils.files.fopen(self.ZYPPER_LOCK) as rfh:
                          data = __salt__['ps.proc_info'](int(rfh.readline()),
                                                          attrs=['pid', 'name', 'cmdline', 'create_time'])
                          data['cmdline'] = ' '.join(data['cmdline'])
                          data['info'] = 'Blocking process created at {0}.'.format(
                              datetime.datetime.utcfromtimestamp(data['create_time']).isoformat())
                          data['success'] = True
                  except Exception as err:
                      data = {'info': 'Unable to retrieve information about blocking process: {0}'.format(err.message),
                              'success': False}
              else:
                  data = {'info': 'Zypper is locked, but no Zypper lock has been found.', 'success': False}
  
              if not data['success']:
                  log.debug("Unable to collect data about blocking process.")
              else:
                  log.debug("Collected data about blocking process.")
  
              __salt__['event.fire_master'](data, self.TAG_BLOCKED)
              log.debug("Fired a Zypper blocked event to the master with the data: %s", data)
              log.debug("Waiting 5 seconds for Zypper gets released...")
              time.sleep(5)
              if not was_blocked:
                  was_blocked = True
  
          if was_blocked:
              __salt__['event.fire_master']({'success': not self.error_msg,
                                             'info': self.error_msg or 'Zypper has been released'},
                                            self.TAG_RELEASED)
          if self.error_msg and not self.__no_raise and not self.__ignore_repo_failure:
              raise CommandExecutionError('Zypper command failure: {0}'.format(self.error_msg))
  
          return (
              self._is_xml_mode() and
              dom.parseString(salt.utils.stringutils.to_str(self.__call_result['stdout'])) or
              self.__call_result['stdout']
          )