docs: def _salt(fun, *args, **kw):
      '''Execute a salt function on a specific minion
  
      Special kwargs:
  
              salt_target
                  target to exec things on
              salt_timeout
                  timeout for jobs
              salt_job_poll
                  poll interval to wait for job finish result
      '''
      try:
          poll = kw.pop('salt_job_poll')
      except KeyError:
          poll = 0.1
      try:
          target = kw.pop('salt_target')
      except KeyError:
          target = None
      try:
          timeout = int(kw.pop('salt_timeout'))
      except (KeyError, ValueError):
          # try to has some low timeouts for very basic commands
          timeout = __FUN_TIMEOUT.get(
              fun,
              900  # wait up to 15 minutes for the default timeout
          )
      try:
          kwargs = kw.pop('kwargs')
      except KeyError:
          kwargs = {}
      if not target:
          infos = get_configured_provider()
          if not infos:
              return
          target = infos['target']
      laps = time.time()
      cache = False
      if fun in __CACHED_FUNS:
          cache = True
          laps = laps // __CACHED_FUNS[fun]
      try:
          sargs = salt.utils.json.dumps(args)
      except TypeError:
          sargs = ''
      try:
          skw = salt.utils.json.dumps(kw)
      except TypeError:
          skw = ''
      try:
          skwargs = salt.utils.json.dumps(kwargs)
      except TypeError:
          skwargs = ''
      cache_key = (laps, target, fun, sargs, skw, skwargs)
      if not cache or (cache and (cache_key not in __CACHED_CALLS)):
          conn = _client()
          runner = _runner()
          rkwargs = kwargs.copy()
          rkwargs['timeout'] = timeout
          rkwargs.setdefault('tgt_type', 'list')
          kwargs.setdefault('tgt_type', 'list')
          ping_retries = 0
          # the target(s) have environ one minute to respond
          # we call 60 ping request, this prevent us
          # from blindly send commands to unmatched minions
          ping_max_retries = 60
          ping = True
          # do not check ping... if we are pinguing
          if fun == 'test.ping':
              ping_retries = ping_max_retries + 1
          # be sure that the executors are alive
          while ping_retries <= ping_max_retries:
              try:
                  if ping_retries > 0:
                      time.sleep(1)
                  pings = conn.cmd(tgt=target,
                                   timeout=10,
                                   fun='test.ping')
                  values = list(pings.values())
                  if not values:
                      ping = False
                  for v in values:
                      if v is not True:
                          ping = False
                  if not ping:
                      raise ValueError('Unreachable')
                  break
              except Exception:
                  ping = False
                  ping_retries += 1
                  log.error('%s unreachable, retrying', target)
          if not ping:
              raise SaltCloudSystemExit('Target {0} unreachable'.format(target))
          jid = conn.cmd_async(tgt=target,
                               fun=fun,
                               arg=args,
                               kwarg=kw,
                               **rkwargs)
          cret = conn.cmd(tgt=target,
                          fun='saltutil.find_job',
                          arg=[jid],
                          timeout=10,
                          **kwargs)
          running = bool(cret.get(target, False))
          endto = time.time() + timeout
          while running:
              rkwargs = {
                  'tgt': target,
                  'fun': 'saltutil.find_job',
                  'arg': [jid],
                  'timeout': 10
              }
              cret = conn.cmd(**rkwargs)
              running = bool(cret.get(target, False))
              if not running:
                  break
              if running and (time.time() > endto):
                  raise Exception('Timeout {0}s for {1} is elapsed'.format(
                      timeout, pprint.pformat(rkwargs)))
              time.sleep(poll)
          # timeout for the master to return data about a specific job
          wait_for_res = float({
              'test.ping': '5',
          }.get(fun, '120'))
          while wait_for_res:
              wait_for_res -= 0.5
              cret = runner.cmd(
                  'jobs.lookup_jid',
                  [jid, {'__kwarg__': True}])
              if target in cret:
                  ret = cret[target]
                  break
              # recent changes
              elif 'data' in cret and 'outputter' in cret:
                  ret = cret['data']
                  break
              # special case, some answers may be crafted
              # to handle the unresponsivness of a specific command
              # which is also meaningful, e.g. a minion not yet provisioned
              if fun in ['test.ping'] and not wait_for_res:
                  ret = {
                      'test.ping': False,
                  }.get(fun, False)
              time.sleep(0.5)
          try:
              if 'is not available.' in ret:
                  raise SaltCloudSystemExit(
                      'module/function {0} is not available'.format(fun))
          except SaltCloudSystemExit:
              raise
          except TypeError:
              pass
          if cache:
              __CACHED_CALLS[cache_key] = ret
      elif cache and cache_key in __CACHED_CALLS:
          ret = __CACHED_CALLS[cache_key]
      return ret