Returns the public resource.

@param string $url url to request.
@param array $options HTTP request options. Keys: query, data, headers.
@param boolean $parseResponse Whether to parse response.
@return mixed the response.
@throws ErrorException
510318
public function makeRequest($url, $options = [], $parseResponse = true)
    {
        return $this->request($url, $options, $parseResponse, function ($url, $method, $headers, $data) {
            return $this->getHttpClient()->retrieveResponse($url, $data, $headers, $method);
        });
    }
205626
public function post($url, array $options = [])
    {
        return $this->responseBuilder->build($this->send(new Request('POST', $url), $options));
    }
590697
public function get($name, $options = array(), $usePeeringServiceManagers = true)
    {
        if (empty($options['name'])) {
            $options['name'] = $name;
        }

        return parent::get($name, $options, $usePeeringServiceManagers);
    }
782631
public function get($url, $params = null) {
    $this->params = $params;
    $this->method = 'GET';
    $this->url = $url;

    return $this->request();
  }
960953
public function request($method, $url, $options)
    {
        $request = $this->authClient->getAuthenticatedRequest($method, $url, $this->getAccessToken());

        return $this->httpClient->send($request, $options);
    }
1085662
public function request(string $url, string $method = 'GET', array $options = [], $returnRaw = false)
    {
        if (empty($this->middlewares)) {
            $this->registerHttpMiddlewares();
        }

        $response = $this->performRequest($url, $method, $options);

        return $returnRaw ? $response : $this->castResponseToType($response, $this->app->config->get('response_type'));
    }
159240
public static function get($url, $query = [], $options = [])
    {
        $options['query'] = $query;
        return self::doRequest('get', $url, $options);
    }
473575
public function readFromUrl($url, array $options = []): Certificate
    {
        $urlHost = parse_url($url, PHP_URL_HOST);

        if ($urlHost === null) {
            $urlHost = $url;
        }
    
        $urlPort = parse_url($url, PHP_URL_PORT);
    
        if ($urlPort === null) {
            $urlPort = self::DEFAULT_PORT;
        }
    
        $options = $this->prepareReadFromUrlOptions($options);

        $streamContext = stream_context_create(array(
            'ssl' => array(
                'capture_peer_cert' => TRUE,
                'verify_peer'       => FALSE,
                'verify_peer_name'  => FALSE
            )
        ));

        $stream = @stream_socket_client(
            sprintf('ssl://%s:%d', $urlHost, $urlPort),
            $errorNumber,
            $errorString,
            $options[self::OPT_CONNECTION_TIMEOUT],
            STREAM_CLIENT_CONNECT,
            $streamContext
        );

        if ($stream) {
            $streamParams = stream_context_get_params($stream);

            $certResource = $streamParams['options']['ssl']['peer_certificate'];

            return new Certificate($this->certResourceToString($certResource));
        }
        
        throw new Exception(
            sprintf('Unable to connect to %s:%d', $urlHost, $urlPort),
            Exception::CONNECTION_PROBLEM
        );
    }
595368
public function get($url, $params = array())
    {
        $request = $this->provider->request($url, $params);
        $response = $this->client->send($request);

        $data = $response->getBody()->getContents();
        $format = $this->getFormat($params, $response);

        return $this->serializer->deserialize($data, null, $format);
    }
51033
function get(options) {
    request({url: options.url, jar : true},
            function (error, response, body) {
        if (!error && response.statusCode == 200) {
            if( options.json ) {
                try {
                    var data = JSON.parse(body);
                    options.callback(null, data);
                } catch(e) {
                    e.response = body;
                    options.callback(e);
                }
            } else {
                options.callback(null, body);
            }
        } else {
            if( !error ) error = {status:response.statusCode};
            options.callback(error);
        }
    }
    );
}
1168864
static public function get($url, $data=null, $options=null)
    {
        $instance = new static('GET', $url, $data, $options);
        return $instance->getResponse();
    }
1244699
public function makeSignedRequest($url, $options = [], $parseResponse = true)
	{
		$token = $this->getAccessTokenData();
		if (isset($token)) {
			$params = '';
			ksort($options['query']);
			foreach ($options['query'] as $k => $v) {
				$params .= $k . '=' . $v;
			}
			$options['query']['sig'] = md5($params . md5($token['access_token'] . $this->clientSecret));
			$options['query']['access_token'] = $token['access_token'];
		}
		return parent::makeSignedRequest($url, $options, $parseResponse);
	}
1212619
protected function getUrl(ServerRequestInterface $request, array $options)
    {
        $url = $options['url'];
        if ($options['queryParam'] !== null && $request->getMethod() === 'GET') {
            $query = urlencode($options['queryParam']) . '=' . urlencode($request->getRequestTarget());
            if (strpos($url, '?') !== false) {
                $query = '&' . $query;
            } else {
                $query = '?' . $query;
            }

            $url .= $query;
        }

        return $url;
    }
1003624
public static function post($url, $headers = array(), $data = array(), $options = array()) {
		return self::request($url, $headers, $data, self::POST, $options);
	}
290236
public function get(string $url, array $headers = [])
    {
        $ctx = $this->getContext('GET', null, $headers);
        $response = file_get_contents($url, false, $ctx);
        $this->saveCookies($http_response_header);

        return $response;
    }
993676
public function get($url, array $params = [], array $headers = [])
    {
        $url = $this->formatUrl($url, $url !== 'current/Me', $url == $this->nextUrl);

        try {
            $request = $this->createRequest('GET', $url, null, $params, $headers);
            $response = $this->client()->send($request);

            return $this->parseResponse($response, $url != $this->nextUrl);
        } catch (Exception $e) {
            $this->parseExceptionForErrorMessages($e);
        }
    }
1182904
public function delete($url, array $options = [])
    {
        if ($token = $this->fetch('token')) {
            $this->bearer($token);
        }

        if (array_key_exists('delete', $this->methodHeaders)) {
            $this->addHeader('Content-Type', $this->methodHeaders['delete']['content_type']);
            $this->addHeader('Accept', $this->methodHeaders['delete']['accept']);
        }

        try {
            $response = $this->request->delete(sprintf('%s?%s', $this->getRealUrl($url, 'delete'), http_build_query(array_merge([$this->paramKey => $this->apiKey], $options))), [
                'headers' => $this->headers,
            ]);
        } catch (RequestException $e) {
            $response = $e->getResponse();
        }

        return $this->convertToSymfonyResponse($response);
    }