docs: def _return_pub_multi(self, rets, ret_cmd='_return', timeout=60, sync=True):
          '''
          Return the data from the executed command to the master server
          '''
          if not isinstance(rets, list):
              rets = [rets]
          jids = {}
          for ret in rets:
              jid = ret.get('jid', ret.get('__jid__'))
              fun = ret.get('fun', ret.get('__fun__'))
              if self.opts['multiprocessing']:
                  fn_ = os.path.join(self.proc_dir, jid)
                  if os.path.isfile(fn_):
                      try:
                          os.remove(fn_)
                      except (OSError, IOError):
                          # The file is gone already
                          pass
              log.info('Returning information for job: %s', jid)
              load = jids.setdefault(jid, {})
              if ret_cmd == '_syndic_return':
                  if not load:
                      load.update({'id': self.opts['id'],
                                   'jid': jid,
                                   'fun': fun,
                                   'arg': ret.get('arg'),
                                   'tgt': ret.get('tgt'),
                                   'tgt_type': ret.get('tgt_type'),
                                   'load': ret.get('__load__'),
                                   'return': {}})
                  if '__master_id__' in ret:
                      load['master_id'] = ret['__master_id__']
                  for key, value in six.iteritems(ret):
                      if key.startswith('__'):
                          continue
                      load['return'][key] = value
              else:
                  load.update({'id': self.opts['id']})
                  for key, value in six.iteritems(ret):
                      load[key] = value
  
              if 'out' in ret:
                  if isinstance(ret['out'], six.string_types):
                      load['out'] = ret['out']
                  else:
                      log.error(
                          'Invalid outputter %s. This is likely a bug.',
                          ret['out']
                      )
              else:
                  try:
                      oput = self.functions[fun].__outputter__
                  except (KeyError, AttributeError, TypeError):
                      pass
                  else:
                      if isinstance(oput, six.string_types):
                          load['out'] = oput
              if self.opts['cache_jobs']:
                  # Local job cache has been enabled
                  salt.utils.minion.cache_jobs(self.opts, load['jid'], ret)
  
          load = {'cmd': ret_cmd,
                  'load': list(six.itervalues(jids))}
  
          def timeout_handler(*_):
              log.warning(
                 'The minion failed to return the job information for job %s. '
                 'This is often due to the master being shut down or '
                 'overloaded. If the master is running, consider increasing '
                 'the worker_threads value.', jid
              )
              return True
  
          if sync:
              try:
                  ret_val = self._send_req_sync(load, timeout=timeout)
              except SaltReqTimeoutError:
                  timeout_handler()
                  return ''
          else:
              with tornado.stack_context.ExceptionStackContext(timeout_handler):
                  ret_val = self._send_req_async(load, timeout=timeout, callback=lambda f: None)  # pylint: disable=unexpected-keyword-arg
  
          log.trace('ret_val = %s', ret_val)  # pylint: disable=no-member
          return ret_val