// GET REST call
772947
func httpGetVolumeProfile(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
	log.Debugf("Received httpGetVolumeProfile: %+v", vars)

	key := vars["key"]

	collections.volumeProfileMutex.Lock()
	defer collections.volumeProfileMutex.Unlock()
	obj := collections.volumeProfiles[key]
	if obj == nil {
		log.Infof("volumeProfile %s not found", key)
		return nil, errors.New("volumeProfile not found")
	}

	// Return the obj
	return obj, nil
}
899406
func (r *rest) Get(c *gin.Context) {
	if resDTO, err := r.service.Retrieve(c.Param("profileId")); err != nil {
		c.JSON(apihelper.BuildResponseError(err))
	} else {
		c.JSON(http.StatusOK, resDTO)
	}
}
844128
func GetRequest(ctx context.Context) (*http.Request, error) {
	if r, ok := ctx.Value("http.request").(*http.Request); r != nil && ok {
		return r, nil
	}
	return nil, ErrNoRequestContext
}
286489
func (r *REST) Get(ctx context.Context, id string, options *metav1.GetOptions) (runtime.Object, error) {
	name, tag, err := nameAndTag(id)
	if err != nil {
		return nil, err
	}

	imageStream, err := r.imageStreamRegistry.GetImageStream(ctx, name, options)
	if err != nil {
		return nil, err
	}

	image, err := r.imageFor(ctx, tag, imageStream)
	if err != nil {
		return nil, err
	}

	return newISTag(tag, imageStream, image, false)
}
1366156
func (mj *Client) GetData(mdr *DataRequest, res interface{}, options ...RequestOptions) (err error) {
	url := buildDataURL(mj.apiBase, mdr)
	req, err := createRequest("GET", url, nil, nil, options...)
	if err != nil {
		return err
	}

	_, _, err = mj.httpClient.Send(req).Read(res).Call()
	return err
}
18487
func GET(ctx log.Interface, server string, strategy auth.Strategy, URI string, headers map[string]string, res interface{}) error {
	return performRequest(ctx, server, strategy, "GET", URI, headers, nil, res, MaxRedirects)
}
1062970
func (c *Client) Get() *Request {
	req := c.Request()
	req.Method("GET")
	return req
}
286607
func (r *GroupRolloutService) Get(appId string, groupId string) *GroupRolloutGetCall {
	c := &GroupRolloutGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.appId = appId
	c.groupId = groupId
	return c
}
713510
func (s *UsersProfileService) Get() *UsersProfileGetCall {
	var call UsersProfileGetCall
	call.service = s
	return &call
}
771997
func (c *Client) Get(url string) (*http.Response, error) {
	get := func(args ...interface{}) (*http.Response, error) {
		return c.HTTPClient.Get(args[0].(string))
	}

	resp, err := c.HTTPClient.Get(url)
	if err != nil {
		if c.ExponentialBackoff {
			return c.backoff(get, url)
		}
		return nil, err
	}

	if resp.StatusCode >= http.StatusInternalServerError && c.ExponentialBackoff {
		return c.backoff(get, url)
	}

	return resp, err
}
885453
func (s *REST) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
	opts := metav1.GetOptions{}
	if options != nil {
		opts = *options
	}
	namespace, err := s.client.Get(name, opts)
	if err != nil {
		return nil, err
	}
	return projectutil.ConvertNamespaceFromExternal(namespace), nil
}
737518
func (api *ServicesAPI) Get(id string) (service *Service, err error) {
	res, err := api.client.restClient.Get(api.client.Endpoint+serviceUrl+id, api.client.options.TokenOptions)
	if err != nil {
		return
	}
	defer res.Body.Close()
	res, err = getError(res)
	if err != nil {
		return
	}
	var result Service
	err = json.NewDecoder(res.Body).Decode(&result)
	return &result, err
}
216656
func Get(url string) (resp *http.Response, err error) {
	c := New()
	return c.Get(url)
}
763744
func (p *PullRequestComment) GetURL() string {
	if p == nil || p.URL == nil {
		return ""
	}
	return *p.URL
}
1118510
func (r *Request) Get(url string) (*Response, error) {
	return r.Execute(MethodGet, url)
}
1049000
func (r Resource) Get(request *restful.Request, response *restful.Response) {
	if resource, ok := r.Parent.(GetSupported); ok {
		context := r.Context.NewAPIContext()
		if resource.GetAuthRequired() {
			auth, err := context.Authentication(request)
			if err != nil || auth == nil {
				ErrorResponseHandler(request, response, err, NewErrorResponse(
					http.StatusUnauthorized,
					"Invalid accesstoken",
					"GET"))
				return
			}
		}

		params, err := Validate(request, resource.GetParams())
		if err != nil {
			ErrorResponseHandler(request, response, err, NewErrorResponse(
				http.StatusBadRequest,
				err,
				"validate"))
			return
		}

		if _, ok := r.Parent.(GetIDSupported); ok {
			//if _, ok := params["ids[]"]; ok { //FIXME
			if _, ok := request.Request.URL.Query()["ids[]"]; ok {
				r.GetByIDs(request, response)
				return
			}
		}

		resource.Get(context, request, response, params)
		request.SetAttribute("context", context)
	}
}
511834
func (c *Client) Get(endpoint string, resp interface{}) error {
	return c.Result(c.NewJsonRequest(GET, endpoint, nil), resp)
}