def _build_request (self, method, params):
        self._cached_request_args = (method, params) # backup for retry
        if self._use_cache and rcache.the_rcache:
            self._cached_result = rcache.the_rcache.get (self._get_ident (), self._use_cache)
            if self._cached_result is not None:
                self._cached_result.meta = self._meta
                self._callback and tuple_cb (self._cached_result, self._callback)
                return
            else:
                self._use_cache = False

        requests = 0
        while self._avails ():
            if self._cluster.get_name () != "__socketpool__":
                asyncon = self._get_connection (None)
            else:
                asyncon = self._get_connection (self._uri)

            self._auth = self._auth or asyncon.get_auth ()
            _reqtype = self._reqtype.lower ()
            rs = Dispatcher (
                self._cv, asyncon.address,
                ident = not self._mapreduce and self._get_ident () or None,
                filterfunc = self._filter, cachefs = self._cachefs,
                callback = self._collect
            )
            self._requests [rs] = asyncon
            args = (params, self._headers, self._auth, self._logger, self._meta)
            try:
                if _reqtype in ("ws", "wss"):
                    handler = ws_request_handler.RequestHandler
                    request = ws_request.Request (self._uri, *args)
                else:
                    if not self._use_cache:
                        self._add_header ("Cache-Control", "no-cache")
                    handler = http_request_handler.RequestHandler
                    try:
                        class_ = self.proto_map [_reqtype]
                    except KeyError:
                        if _reqtype == "upload":
                            request = http_request.HTTPMultipartRequest (self._uri, _reqtype, *args)
                        else:
                            request = http_request.HTTPRequest (self._uri, _reqtype, *args)
                    else:
                        request = class_ (self._uri, method, *args)
                requests += self._handle_request (request, rs, asyncon, handler)

            except:
                self._logger ("Request Creating Failed", "fail")
                self._logger.trace ()
                rs.request_failed ()
                asyncon.set_active (False)
                continue

        if requests:
            self._request = request # sample for unitest
            trigger.wakeup ()

        if _reqtype [-3:] == "rpc":
            return self