Switch default

Author: cceckman-at-fastly

cache/core/core.go

@@ -259,30 +259,26 @@ type LookupOptions struct {
 	// value of 0 means to read to the end of the object.
 	To uint64
 
-	// AlwaysUseRequestedRange forces the provided range to be used during streaming.
+	// LegacyReturnWholeBody restores a legacy behavior around range requests.
 	//
-	// If false, under certain circumstances the entire body will be returned
-	// instead of just the requested range.
-	//
-	// If:
-	//
-	// - AlwaysUseRequestedRange is false
+	// In SDK v1.4.2 and earlier, under certain circumstances the requested range
+	// (From/To) would be ignored. Specifically, if:
+	// - The lookup (reader) is concurrent with the writer of the body
 	// - The size of the cached item's body was not provided by the writer
 	// - The reader requests a specific range of the cached item's body
 	//   (`From` and `To` are provided in LookupOptions or GetBodyOptions)
-	// - The writer and reader are concurrent, i.e. the body is streamed from
-	//   the writer to the reader
-	//
-	// then the core cache API will ignore the requested range, and provide
-	// the entire body.
+	// then the core cache API would ignore the requested range and provide
+	// the entire body, instead of providing just the requested range.
 	//
-	// Setting AlwaysUseRequestedRange to true changes this behavior:
-	// - The reader will block until the start of the requested range has been
-	//   written by the writer. This blocking happens within the
-	//   TransactionLookup or Lookup call (if the range is provided in
-	//   LookupOptions) or in GetBody (if the range is provided to GetBody).
+	// In SDK v1.4.3, the default behavior changed. In a concurrent read/write:
+	// - If From and To are nonzero, the reader will block until the start of
+	//   the requested range has been provided by the writer.
 	// - Only the requested range will be returned to the reader.
-	AlwaysUseRequestedRange bool
+	//
+	// Note that the full body is still provided if the range is invalid.
+	//
+	// LegacyReturnWholeBody restores the v1.4.2 behavior.
+	LegacyReturnWholeBody bool
 }
 
 func abiLookupOptions(opts LookupOptions) (fastly.CacheLookupOptions, error) {
@@ -297,7 +293,7 @@ func abiLookupOptions(opts LookupOptions) (fastly.CacheLookupOptions, error) {
 		abiOpts.SetRequest(req)
 	}
 
-	abiOpts.SetAlwaysUseRequestedRange(opts.AlwaysUseRequestedRange)
+	abiOpts.SetAlwaysUseRequestedRange(!opts.LegacyReturnWholeBody)
 
 	return abiOpts, nil
 }

cache/core/core_test.go

@@ -209,7 +209,7 @@ func ExampleFound_GetRange() {
 	fmt.Printf("The cached value was: %s", cachedStr)
 }
 
-func ExampleLookupOptions_AlwaysUseRequestedRange() {
+func ExampleLookupOptions_LegacyReturnWholeBody() {
 	const (
 		key      = "my_key"
 		contents = "my cached object"
@@ -227,25 +227,45 @@ func ExampleLookupOptions_AlwaysUseRequestedRange() {
 	}
 
 	// With the write still outstanding, start a lookup for a specific range.
-	f, err := core.Lookup([]byte("my_key"), core.LookupOptions{
-		From:                    3,
-		To:                      8,
-		AlwaysUseRequestedRange: true,
+	legacy, err := core.Lookup([]byte(key), core.LookupOptions{
+		From:                  3,
+		To:                    8,
+		LegacyReturnWholeBody: true,
 	})
 	if err != nil {
 		panic(err)
 	}
+	// With the write still outstanding, start a lookup for a specific range.
+	updated, err := core.Lookup([]byte(key), core.LookupOptions{
+		From: 3,
+		To:   8,
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	// The read and write are concurrent, and with an unknown length.
+	// In the legacy mode, we'll see the whole body;
+	// in the updated mode, we'll see just the range.
 
-	// Write and flush:
+	// Finish writing the body:
 	if _, err := io.WriteString(w, contents); err != nil {
 		panic(err)
 	}
 
-	cachedStr, err := io.ReadAll(f.Body)
+	legacyStr, err := io.ReadAll(legacy.Body)
+	if err != nil {
+		panic(err)
+	}
+	updatedStr, err := io.ReadAll(updated.Body)
 	if err != nil {
 		panic(err)
 	}
-	if string(cachedStr) != "cached" {
-		panic(fmt.Sprintf("got: %q, want: %q", cachedStr, "cached"))
+
+	if got, want := string(legacyStr), "my cached object"; got != want {
+		panic(fmt.Sprintf("got: %q, want: %q", got, want))
+	}
+	if got, want := string(updatedStr), "cached"; got != want {
+		panic(fmt.Sprintf("got: %q, want: %q", got, want))
 	}
 }