Perform a LIST request.
 @see Client#request
507472
def list(path, params = {}, headers = {})
      params = params.merge(list: true)
      request(:get, path, params, headers)
    end
815212
def list_requests(status=None):
    '''
    
    '''
    if status:
        url = '{0}/request?status={1}'.format(_base_url(), status)
    else:
        url = '{0}/request'.format(_base_url())

    reqs = _paginate(url,
                     "requests",
                     method='GET',
                     decode=True,
                     decode_type='json',
                     raise_error=False,
                     header_dict={
                         'X-DC-DEVKEY': _api_key(),
                         'Content-Type': 'application/json',
                     }
    )

    ret = {'requests': reqs}
    return ret
591038
public function listAction(Request $request, $type = null)
    {
        $this->type = $type;

        return parent::listAction($request);
    }
894910
def send_request(req, &block)
      @last_response = @http.request(req.delete(:method), req.delete(:uri), req, &block)
    end
675914
def ListClients(self, request, timeout=None):
    
    return self._RetryLoop(
        lambda t: self._stub.ListClients(request, timeout=t))
1192238
private function createHttpRequest(ListKeysRequest $listRequest)
    {
        $path    = $this->buildKeysPath($listRequest->type, $listRequest->bucket);
        $request = $this->client->createRequest('GET', $path);
        $query   = $request->getQuery();

        // stream result does not work propertly for http ? :(
        $request->setHeader('Accept', 'application/json');
        $query->add('keys', 'true');

        if ($listRequest->timeout != null) {
            $query->add('timeout', $listRequest->timeout);
        }

        return $request;
    }
155108
public function index(ListRequest $request)
    {
        return $this->paginate($this->service->index($request->all(), $request->getParams()['limit'],
            ['path' => 'asc']));
    }
794242
public function send(Request $request)
    {
        $response  = new ListKeysResponse();
        $rpbGetReq = $this->createRpbMessage($request);
        $socket    = $this->client->emit($rpbGetReq, RiakMessageCodes::LIST_KEYS_REQ);
        $iterator  = new ProtoStreamIterator($this->client, $socket, RiakMessageCodes::LIST_KEYS_RESP);

        $response->iterator = new ProtoListKeysResponseIterator($iterator);

        return $response;
    }
567315
def make_request(uri)
        http_client.start do |http|
          req = Net::HTTP::Get.new(uri.request_uri, @headers)
          req.basic_auth(@username, @password)
          http.request(req)
        end
      end
48345
def batch(request, request_options = {})
      client.post(Protocol.batch_uri(name), request.to_json, :batch, request_options)
    end
782925
public function listAction(Request $request = null)
    {
        $this->admin->checkAccess('list');

        if ($listMode = $request->get('_list_mode')) {
            $this->admin->setListMode($listMode);
        }

        $datagrid = $this->admin->getDatagrid();
        $datagrid->setValue('context', null, $this->admin->getPersistentParameter('context'));

        $formView = $datagrid->getForm()->createView();

        // set the theme for the current Admin Form
        $this->setFormTheme($formView, $this->admin->getFilterTheme());

        return $this->render($this->admin->getTemplate('list'), [
            'action' => 'list',
            'form' => $formView,
            'datagrid' => $datagrid,
            'csrf_token' => $this->getCsrfToken('sonata.batch'),
        ]);
    }
1139982
public function send(Request $request)
    {
        $response = new ListResponse();
        $rpbReq   = $this->createRpbMessage($request);
        $socket   = $this->client->emit($rpbReq, RiakMessageCodes::LIST_BUCKETS_REQ);
        $iterator = new ProtoStreamIterator($this->client, $socket, RiakMessageCodes::LIST_BUCKETS_RESP);

        $response->iterator = new ProtoListResponseIterator($iterator);

        return $response;
    }
914584
def client_list(self):
        
        fut = self.execute(b'CLIENT', b'LIST', encoding='utf-8')
        return wait_convert(fut, to_tuples)
111857
def requests_list(self, status=None, **kwargs):
        ""
        api_path = "/api/v2/requests.json"
        api_query = {}
        if "query" in kwargs.keys():
            api_query.update(kwargs["query"])
            del kwargs["query"]
        if status:
            api_query.update({
                "status": status,
            })
        return self.call(api_path, query=api_query, **kwargs)
365109
def lists
      response = @@soap.getClientLists(:apiKey => @apiKey, :clientID => @clientID)
      lists = handle_response response.client_GetListsResult
      lists.collect {|list| List.new(list.listID, list.name, :apiKey=> @apiKey)}
    end
757151
def do_request(method, url, options = {})
      begin
        response = self.class.send(method, api_url(url), options)
        check_response_codes(response)
        response.parsed_response
      rescue Timeout::Error
        raise Unavailable.new('Service Unavailable')
      end
    end
120537
public ListPipelinesResponse listPipelines(ListPipelinesRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");
        InternalRequest internalRequest = createRequest(HttpMethodName.GET, request, PIPELINE);
        return invokeHttpClient(internalRequest, ListPipelinesResponse.class);
    }