func transaction(ctx context.Context) []byte { v := ctx.Value(ContextKey("transaction")) if v == nil { return nil } else { return v.([]byte) } }
// baseUrl gets the base url active for the datastore service // defaults to "https://www.googleapis.com/datastore/v1beta2/datasets/" if none was specified func baseUrl(ctx context.Context) string { v := ctx.Value(ContextKey("base_url")) if v == nil { return "https://www.googleapis.com/datastore/v1beta2/datasets/" } else { return v.(string) } }
func contextClient(ctx context.Context) (*http.Client, error) { for _, fn := range contextClientFuncs { c, err := fn(ctx) if err != nil { return nil, err } if c != nil { return c, nil } } if hc, ok := ctx.Value(HTTPClient).(*http.Client); ok { return hc, nil } return http.DefaultClient, nil }
// Upload starts the process of a resumable upload with a cancellable context. // It retries indefinitely (with a pause of uploadPause between attempts) until cancelled. // It is called from the auto-generated API code and is not visible to the user. // rx is private to the auto-generated API code. func (rx *ResumableUpload) Upload(ctx context.Context) (*http.Response, error) { var res *http.Response var err error for { res, err = rx.transferChunks(ctx) if err != nil || res.StatusCode == http.StatusCreated || res.StatusCode == http.StatusOK { return res, err } select { // Check for cancellation case <-ctx.Done(): res.StatusCode = http.StatusRequestTimeout return res, ctx.Err() default: } sleep(uploadPause) } return res, err }
func (rx *ResumableUpload) transferChunks(ctx context.Context) (*http.Response, error) { start, res, err := rx.transferStatus() if err != nil || res.StatusCode != statusResumeIncomplete { return res, err } for { select { // Check for cancellation case <-ctx.Done(): res.StatusCode = http.StatusRequestTimeout return res, ctx.Err() default: } reqSize := rx.ContentLength - start if reqSize > chunkSize { reqSize = chunkSize } r := io.NewSectionReader(rx.Media, start, reqSize) req, _ := http.NewRequest("POST", rx.URI, r) req.ContentLength = reqSize req.Header.Set("Content-Range", fmt.Sprintf("bytes %v-%v/%v", start, start+reqSize-1, rx.ContentLength)) req.Header.Set("Content-Type", rx.MediaType) req.Header.Set("User-Agent", rx.UserAgent) res, err = rx.Client.Do(req) start += reqSize if err == nil && (res.StatusCode == statusResumeIncomplete || res.StatusCode == http.StatusOK) { rx.mu.Lock() rx.progress = start // keep track of number of bytes sent so far rx.mu.Unlock() if rx.Callback != nil { rx.Callback(start, rx.ContentLength) } } if err != nil || res.StatusCode != statusResumeIncomplete { break } } return res, err }
// ctxNamespace returns the active namespace for a context. // It defaults to "" if no namespace was specified. func ctxNamespace(ctx context.Context) string { v, _ := ctx.Value(nsKey{}).(string) return v }
// cc returns the internal *cloudContext (cc) state for a context.Context. // It panics if the user did it wrong. func cc(ctx context.Context) *cloudContext { if c, ok := ctx.Value(contextKey{}).(*cloudContext); ok { return c } panic("invalid context.Context type; it should be created with cloud.NewContext") }