docs: def _executor_internal_inner(self, host, module_name, module_args, inject, port, is_chained=False):
          ''' decides how to invoke a module '''
  
          # allow module args to work as a dictionary
          # though it is usually a string
          new_args = ""
          if type(module_args) == dict:
              for (k,v) in module_args.iteritems():
                  new_args = new_args + "%s='%s' " % (k,v)
              module_args = new_args
  
          module_name = utils.template(self.basedir, module_name, inject)
          module_args = utils.template(self.basedir, module_args, inject, expand_lists=True)
  
          if module_name in utils.plugins.action_loader:
              if self.background != 0:
                  raise errors.AnsibleError("async mode is not supported with the %s module" % module_name)
              handler = utils.plugins.action_loader.get(module_name, self)
          elif self.background == 0:
              handler = utils.plugins.action_loader.get('normal', self)
          else:
              handler = utils.plugins.action_loader.get('async', self)
  
          conditional = utils.template(self.basedir, self.conditional, inject)
          if not getattr(handler, 'BYPASS_HOST_LOOP', False) and not utils.check_conditional(conditional):
              result = utils.jsonify(dict(skipped=True))
              self.callbacks.on_skipped(host, inject.get('item',None))
              return ReturnData(host=host, result=result)
  
          conn = None
          actual_host = inject.get('ansible_ssh_host', host)
          actual_port = port
          if self.transport in [ 'paramiko', 'ssh' ]:
              actual_port = inject.get('ansible_ssh_port', port)
  
          # the delegated host may have different SSH port configured, etc
          # and we need to transfer those, and only those, variables
          delegate_to = inject.get('delegate_to', None)
          if delegate_to is not None:
              delegate_to = utils.template(self.basedir, delegate_to, inject)
              inject = inject.copy()
              interpreters = []
              for i in inject:
                  if i.startswith("ansible_") and i.endswith("_interpreter"):
                      interpreters.append(i)
              for i in interpreters:
                  del inject[i]
              port = C.DEFAULT_REMOTE_PORT
              try:
                  delegate_info = inject['hostvars'][delegate_to]
                  actual_host = delegate_info.get('ansible_ssh_host', delegate_to)
                  actual_port = delegate_info.get('ansible_ssh_port', port)
                  for i in delegate_info:
                      if i.startswith("ansible_") and i.endswith("_interpreter"):
                          inject[i] = delegate_info[i]
              except errors.AnsibleError:
                  actual_host = delegate_to
                  actual_port = port
  
          try:
              if actual_port is not None:
                  actual_port = int(actual_port)
          except ValueError, e:
              result = dict(failed=True, msg="FAILED: Configured port \"%s\" is not a valid port, expected integer" % actual_port)
              return ReturnData(host=host, comm_ok=False, result=result)
  
          try:
              conn = self.connector.connect(actual_host, actual_port)
              if delegate_to or host != actual_host:
                  conn.delegate = host
  
  
          except errors.AnsibleConnectionFailed, e:
              result = dict(failed=True, msg="FAILED: %s" % str(e))
              return ReturnData(host=host, comm_ok=False, result=result)
  
          tmp = ''
          # all modules get a tempdir, action plugins get one unless they have NEEDS_TMPPATH set to False
          if getattr(handler, 'NEEDS_TMPPATH', True):
              tmp = self._make_tmp_path(conn)
  
          result = handler.run(conn, tmp, module_name, module_args, inject)
  
          conn.close()
  
          if not result.comm_ok:
              # connection or parsing errors...
              self.callbacks.on_unreachable(host, result.result)
          else:
              data = result.result
              if 'item' in inject:
                  result.result['item'] = inject['item']
  
              result.result['invocation'] = dict(
                  module_args=module_args,
                  module_name=module_name
              )
  
              if is_chained:
                  # no callbacks
                  return result
              if 'skipped' in data:
                  self.callbacks.on_skipped(host)
              elif not result.is_successful():
                  ignore_errors = self.module_vars.get('ignore_errors', False)
                  self.callbacks.on_failed(host, data, ignore_errors)
              else:
                  self.callbacks.on_ok(host, data)
          return result