Perform get requests
against Catapult API.


@param -> url string [partially qualified]
@param -> join bool
160875
public function get($url, $params=array(), $join=TRUE, $users=TRUE)
    {
      if ($join && $users)
        $url = $this->join($url);
      if ($join && !$users)
        $url = $this->join($url, FALSE);

      return $this->request(API::API_METHOD_GET, $url, $params);
    }
1184122
public RequestResponse doGet(String url, Map<String, Object> headers,
            Map<String, Object> urlParams) {
        RequestResponse requestResponse = initRequestResponse("GET", url, headers, urlParams, null);
        Request.Builder requestBuilder = buildRequest(url, headers, urlParams).get();
        return doCall(client, requestBuilder.build(), requestResponse);
    }
198122
def goto(uri, headers = nil)
      uri = "http://#{uri}" unless uri =~ %r{://}

      request = HtmlUnit::WebRequest.new(::Java::JavaNet::URL.new(uri))

      request.setAdditionalHeaders(headers) if headers
      request.setCharset(@charset)

      rescue_status_code_exception do
        self.page = @webclient.getPage(request)
      end

      url()
    end
852328
def get(query_url,
            headers: {})
      HttpRequest.new(HttpMethodEnum::GET,
                      query_url,
                      headers: headers)
    end
155326
public HttpResponse doHttpGet(String url, Map<String, Object> headers, boolean followRedirect) {
        HttpResponse response = new HttpResponse();
        doGet(url, response, headers, followRedirect);
        return response;
    }
1153150
protected String excuteGet(String url, boolean useURI) throws Exception {
		HttpClient httpClient = getHttpClient();
		HttpUriRequest request = getGetRequest(url, useURI);
		
		HttpResponse httpResponse = httpClient.execute(request);

		String response = parseResponse(url, httpResponse);
		return response;
	}
296872
def _get_request(self, url, params=None, **kwargs):
        
        '''  '''
        
    # construct request kwargs
        request_kwargs = {
            'method': 'GET',
            'url': url,
            'params': params
        }
        for key, value in kwargs.items():
            request_kwargs[key] = value

    # send request and handle response
        return self._request(**request_kwargs)
308129
private HttpGet prepareGet(final String url) {
    final HttpGet httpGet = new HttpGet(this.instanceUrl + url);
    for (final Header header : this.headers) {
      httpGet.addHeader(header);
    }
    return httpGet;
  }
787720
def fget(url, **options)
      uri = _assert_uri(url)
      Responses::ResponsePromise.new { get(uri, options) }
    end
123205
function(params, headers, callback) {
        var url;
        url = this.client.url(false);
        return this.client.get(url, params, headers, callback);
      }
830615
function (url) {
        var self = this;
        this.searching = true;
        this.loadingError = false;
        return $http.get(url)
          .success(function (res) {
            self.searching = false;
            return res.data;
          })
          .error(function () {
            self.searching = false;
            self.loadingError = true;
            return false;
          });
      }
319281
def urljoin_safe(base_url, url, allow_fragments=True):
    ''''''
    try:
        return wpull.url.urljoin(
            base_url, url, allow_fragments=allow_fragments
        )
    except ValueError as error:
        _logger.warning(__(
            _('Unable to parse URL ‘{url}’: {error}.'),
            url=url, error=error
        ))
95751
def get(url, params={}, options={})
      FreebaseAPI.logger.debug("GET #{url}")
      params[:key] = @key if @key
      options = { format: options[:format], query: params }
      options.merge!(@proxy_options)
      response = self.class.get(url, options)
      handle_response(response)
    end
851045
function get(url, opts){
	opts = opts || {};

	return requestp(_.extend(defaults, opts, {
		url: url
	}));
}
289486
public static HttpResponse executeGet(final String url,
                                          final Map<String, Object> parameters) {
        try {
            return executeGet(url, null, null, parameters);
        } catch (final Exception e) {
            LOGGER.error(e.getMessage(), e);
        }
        return null;
    }
204736
function httpGet(parentSpan, urlString, callback) {
    var span = opentracing.globalTracer().startSpan('http.get', { childOf : parentSpan });
    var callbackWrapper = function (err, data) {
        span.finish();
        callback(err, data);
    };

    try {
        var carrier = {};
        opentracing.globalTracer().inject(span, opentracing.FORMAT_TEXT_MAP, carrier);

        var dest = url.parse(urlString);
        var options = {
            host : PROXY_HOST,
            path : dest.path,
            port : PROXY_PORT,
            headers: {
                // User-Agent is required by the GitHub APIs
                'User-Agent': 'LightStep Example',
            }
        };
        for (var key in carrier) {
            options.headers[key] = carrier[key];
        }

        // Create a span representing the https request
        span.setTag('url', urlString);
        span.log({
            event : 'options',
            'options': options,
        });
        return http.get(options, function(response) {
            var bodyBuffer = '';
            response.on('data', function(chunk) {
                bodyBuffer += chunk;
            });
            response.on('end', function() {
                span.log({
                    body   : bodyBuffer,
                    length : bodyBuffer.length,
                });

                var parsedJSON, err;
                try {
                    parsedJSON = JSON.parse(bodyBuffer);
                } catch (exception) {
                    err = {
                        buffer    : bodyBuffer,
                        exception : exception,
                    };
                    span.setTag('error', true);
                    span.log({
                        event : 'error',
                        'error.object': err,
                    });
                }

                callbackWrapper(err, parsedJSON);
            });
        });
    } catch (exception) {
        span.setTag('error', true);
        span.log({
            event : 'error',
            'error.object': exception,
        });
        callbackWrapper(exception, null);
    }
}
1043028
def get(self, url, params=None, **kwargs):
        """"""
        return requests.get(url, params=params, headers=self.add_headers(**kwargs))