Merge pull request #120 from fastly/cw/config-store-size

cee-dub · web-flow · commit a6509022ad0c · 2024-06-24T12:04:11.000-07:00
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
@@ -14,9 +14,11 @@ jobs:
           # Newest supported configuration
           - go-version: '1.22' # pairs with TinyGo 0.31.2
             tinygo-version: '0.31.2'
+            wasmtime-version: 'latest'
           # Oldest supported configuration
           - go-version: '1.21' # pairs with TinyGo 0.29.0
             tinygo-version: '0.29.0'
+            wasmtime-version: '21.0.1' # pairs with TinyGo 0.29.0
 
     steps:
       - uses: actions/checkout@v4
@@ -44,6 +46,8 @@ jobs:
 
       - name: Set up Wasmtime
         uses: bytecodealliance/actions/wasmtime/setup@v1
+        with:
+          version: ${{ matrix.wasmtime-version }}
 
       - name: Check our dependencies
         run: |
diff --git a/configstore/configstore.go b/configstore/configstore.go
@@ -61,8 +61,8 @@ func Open(name string) (*Store, error) {
 	return &Store{d}, nil
 }
 
-// Has checks to see if the item exists in the config store, without allocating
-// any space to read it.
+// Has returns true if the key exists in the config store, without allocating
+// space to read a value.
 func (s *Store) Has(key string) (bool, error) {
 	if s == nil {
 		return false, ErrKeyNotFound
@@ -86,7 +86,7 @@ func (s *Store) Has(key string) (bool, error) {
 	return v, nil
 }
 
-// Get returns the item in the config store with the given key, as a byte slice.
+// GetBytes returns the value in the config store for the given key, if it exists, as a byte slice.
 func (s *Store) GetBytes(key string) ([]byte, error) {
 	if s == nil {
 		return nil, ErrKeyNotFound
@@ -106,16 +106,14 @@ func (s *Store) GetBytes(key string) ([]byte, error) {
 			return nil, err
 		}
 	}
-
 	return v, nil
 }
 
-// Get returns the item in the config store with the given key.
+// Get returns the value in the config store with the given key, if it exists.
 func (s *Store) Get(key string) (string, error) {
 	buf, err := s.GetBytes(key)
 	if err != nil {
 		return "", err
 	}
-
 	return string(buf), nil
 }
diff --git a/integration_tests/config_store/configstore.json b/integration_tests/config_store/configstore.json
diff --git a/integration_tests/config_store/main_test.go b/integration_tests/config_store/main_test.go
@@ -6,6 +6,9 @@ package main
 
 import (
 	"bytes"
+	"strconv"
+	"strings"
+	"sync"
 	"testing"
 
 	"github.com/fastly/compute-sdk-go/configstore"
@@ -60,4 +63,56 @@ func TestConfigStore(t *testing.T) {
 	if got, want := twitter, "https://twitter.com/fastly"; got != want {
 		t.Errorf("Body = %q, want %q", got, want)
 	}
+
+	maxKey := "maximum-length-asciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii-1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000-2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+	max, err := d.Get(maxKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	got := max
+	want := "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+	if got != want {
+		t.Errorf("Body = %q, want %q", got, want)
+	}
+
+	maxUTF8, err := d.Get(strings.Repeat("ゝ", 255))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	got, want = maxUTF8, strings.Repeat("ゝ", 8000)
+	if got != want {
+		t.Errorf("Body = %q, want %q", got, want)
+	}
+}
+
+func TestConfigStoreConcurrently(t *testing.T) {
+	d, err := configstore.Open("configstore")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var wg sync.WaitGroup
+	wg.Add(5)
+	var keys [5]string
+	var values [5][]byte
+	for i := 0; i < 5; i++ {
+		go func(i int) {
+			defer wg.Done()
+			var err error
+			keys[i] = "concurrent " + strconv.Itoa(i)
+			values[i], err = d.GetBytes(keys[i])
+			if err != nil {
+				t.Errorf("%d: GetBytes() error: %v", i, err)
+			}
+		}(i)
+	}
+	wg.Wait()
+	for i := 0; i < 5; i++ {
+		got := values[i]
+		want := bytes.Repeat([]byte{'0' + byte(i)}, i+1)
+		if !bytes.Equal(got, want) {
+			t.Errorf("%d: got: %q want: %q", i, got, want)
+		}
+	}
 }
diff --git a/integration_tests/request_upstream/fastly.toml b/integration_tests/request_upstream/fastly.toml
@@ -8,18 +8,15 @@ manifest_version = 2
 name = "request_upstream"
 service_id = ""
 
-[local_server]
 
-  [local_server.backends]
+[local_server.backends.TheOrigin]
+url = "https://compute-sdk-test-backend.edgecompute.app/"
 
-    [local_server.backends.TheOrigin]
-      url = "https://compute-sdk-test-backend.edgecompute.app/"
+[local_server.backends.TheOrigin2]
+url = "https://compute-sdk-test-backend.edgecompute.app/"
 
-    [local_server.backends.TheOrigin2]
-      url = "https://compute-sdk-test-backend.edgecompute.app/"
+[local_server.backends.example_backend]
+url = "https://example.org/"
 
-    [local_server.backends.example_backend]
-      url = "https://example.org/"
-
-    [local_server.backends.httpme]
-      url = "https://http-me.glitch.me"
+[local_server.backends.httpedge]
+url = "https://http.edgecompute.app/anything/"
diff --git a/integration_tests/request_upstream/main_test.go b/integration_tests/request_upstream/main_test.go
@@ -87,7 +87,7 @@ const bodySize = 64 * 1024
 func TestRequestUpstreamBody(t *testing.T) {
 	body := make([]byte, bodySize)
 	for i := range body {
-		body[i] = byte(i)
+		body[i] = 'A'
 	}
 
 	b, err := fastly.NewHTTPBody()
@@ -124,15 +124,15 @@ func TestRequestUpstreamBody(t *testing.T) {
 }
 
 func requestUpstreamBody(t *testing.T, body io.Reader, size int, chunked bool) {
-	req, err := fsthttp.NewRequest("POST", "https://http-me.glitch.me/?anything", body)
+	req, err := fsthttp.NewRequest("POST", "https://http.edgecompute.app/anything/", body)
 	if err != nil {
 		t.Fatalf("NewRequest: %v", err)
 	}
 
 	req.Header.Set("Content-Type", "application/octet-stream")
 	req.CacheOptions.Pass = true
 
-	resp, err := req.Send(context.Background(), "httpme")
+	resp, err := req.Send(context.Background(), "httpedge")
 	if err != nil {
 		t.Fatalf("Send: %v", err)
 	}
@@ -142,8 +142,9 @@ func requestUpstreamBody(t *testing.T, body io.Reader, size int, chunked bool) {
 		Headers map[string]string `json:"headers"`
 	}
 
-	if err := json.NewDecoder(resp.Body).Decode(&respData); err != nil {
-		t.Fatalf("Decode: %v", err)
+	gotBody := new(bytes.Buffer)
+	if err := json.NewDecoder(io.TeeReader(resp.Body, gotBody)).Decode(&respData); err != nil {
+		t.Fatalf("Decode: %v\nBody:\n%s", err, gotBody.String())
 	}
 
 	var teWant, clWant string
diff --git a/internal/abi/fastly/hostcalls_guest.go b/internal/abi/fastly/hostcalls_guest.go
@@ -11,6 +11,7 @@ import (
 	"math"
 	"net"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/fastly/compute-sdk-go/internal/abi/prim"
@@ -2436,10 +2437,27 @@ func fastlyDictionaryOpen(
 // Dictionary represents a Fastly edge dictionary, a collection of read-only
 // key/value pairs. For convenience, keys are modeled as Go strings, and values
 // as byte slices.
+//
+// NOTE: wasm, by definition, is a single-threaded execution environment. This
+// allows us to use valueBuf scratch space between the guest and host to avoid
+// allocations any larger than necessary, without locking.
 type Dictionary struct {
 	h dictionaryHandle
+
+	mu       sync.Mutex // protects valueBuf
+	valueBuf [dictionaryMaxValueLen]byte
 }
 
+// Dictionaries are subject to very specific limitations: 255 character keys and 8000 character values, utf-8 encoded.
+// The current storage collation limits utf-8 representations to 3 bytes in length.
+// https://docs.fastly.com/en/guides/about-edge-dictionaries#limitations-and-considerations
+// https://dev.mysql.com/doc/refman/8.4/en/charset-unicode-utf8mb3.html
+// https://en.wikipedia.org/wiki/UTF-8#Encoding
+const (
+	dictionaryMaxKeyLen   = 255 * 3  // known maximum size for config store keys: 755 bytes, for 255 3-byte utf-8 encoded characters
+	dictionaryMaxValueLen = 8000 * 3 // known maximum size for config store values: 24,000 bytes, for 8000 3-byte utf-8 encoded characters
+)
+
 // OpenDictionary returns a reference to the named dictionary, if it exists.
 func OpenDictionary(name string) (*Dictionary, error) {
 	var d Dictionary
@@ -2452,7 +2470,6 @@ func OpenDictionary(name string) (*Dictionary, error) {
 	).toError(); err != nil {
 		return nil, err
 	}
-
 	return &d, nil
 }
 
@@ -2477,42 +2494,42 @@ func fastlyDictionaryGet(
 	nWritten prim.Pointer[prim.Usize],
 ) FastlyStatus
 
-// Get the value for key, as a byte slice, if it exists.
-func (d *Dictionary) GetBytes(key string) ([]byte, error) {
-	keyBuffer := prim.NewReadBufferFromString(key).Wstring()
-	n := DefaultMediumBufLen // Longest (8192) = Config Store limit; typical values likely less than 1024
-	for {
-		buf := prim.NewWriteBuffer(n)
-		status := fastlyDictionaryGet(
-			d.h,
-			keyBuffer.Data, keyBuffer.Len,
-			prim.ToPointer(buf.Char8Pointer()), buf.Cap(),
-			prim.ToPointer(buf.NPointer()),
-		)
-		if status == FastlyStatusBufLen && n < dictionaryValueMaxLen {
-			// The Dictionary API cannot return the needed size with this error.
-			// Instead of perfectly adapting, we allocate the maximum length a value can have.
-			n = dictionaryValueMaxLen
-			continue
-		}
-		if err := status.toError(); err != nil {
-			return nil, err
-		}
-		return buf.AsBytes(), nil
+// Get the value for key, if it exists. The returned slice's backing array is
+// shared between multiple calls to getBytesUnlocked.
+func (d *Dictionary) getBytesUnlocked(key string) ([]byte, error) {
+	keyBuffer := prim.NewReadBufferFromString(key)
+	if keyBuffer.Len() > dictionaryMaxKeyLen {
+		return nil, FastlyStatusInval.toError()
+	}
+	buf := prim.NewWriteBufferFromBytes(d.valueBuf[:]) // fresh slice of backing array
+	keyStr := keyBuffer.Wstring()
+	status := fastlyDictionaryGet(
+		d.h,
+		keyStr.Data, keyStr.Len,
+		prim.ToPointer(buf.Char8Pointer()), buf.Cap(),
+		prim.ToPointer(buf.NPointer()),
+	)
+	if err := status.toError(); err != nil {
+		return nil, err
 	}
+	return buf.AsBytes(), nil
 }
 
-// Get the value for key, if it exists.
-func (d *Dictionary) Get(key string) (string, error) {
-	buf, err := d.GetBytes(key)
+// GetBytes returns a slice of newly-allocated memory for the value
+// corresponding to key.
+func (d *Dictionary) GetBytes(key string) ([]byte, error) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	v, err := d.getBytesUnlocked(key)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-
-	return string(buf), nil
+	p := make([]byte, len(v))
+	copy(p, v)
+	return p, nil
 }
 
-// Has returns whether a value exists.
+// Has returns true if key is found.
 func (d *Dictionary) Has(key string) (bool, error) {
 	keyBuffer := prim.NewReadBufferFromString(key).Wstring()
 	var npointer prim.Usize = 0
diff --git a/internal/abi/fastly/types.go b/internal/abi/fastly/types.go
@@ -185,12 +185,11 @@ func IsFastlyError(err error) (FastlyStatus, bool) {
 }
 
 const (
-	ipBufLen              = 16   // known size for IP address buffers
-	dnsBufLen             = 256  // known size for "DNS" values, enough to hold the longest possible hostname or domain name
-	dictionaryValueMaxLen = 8192 // known size for maximum config store value https://docs.fastly.com/en/guides/about-edge-dictionaries#limitations-and-considerations
+	ipBufLen  = 16  // known size for IP address buffers
+	dnsBufLen = 256 // known size for "DNS" values, enough to hold the longest possible hostname or domain name
 
 	DefaultSmallBufLen  = 128  // default size for "typically-small" values with variable sizes: HTTP methods, header names, tls protocol names, cipher suites
-	DefaultMediumBufLen = 1024 // default size for values between small and large with variable sizes
+	DefaultMediumBufLen = 1024 // default size for values between small and large, with variable sizes
 	DefaultLargeBufLen  = 8192 // default size for "typically-large" values with variable sizes; header values, URLs.
 )
 
diff --git a/internal/abi/prim/prim.go b/internal/abi/prim/prim.go
@@ -115,7 +115,7 @@ func (b *WriteBuffer) NValue() Usize {
 
 // AsBytes returns a slice of the buffer's data as a byte slice.
 func (b *WriteBuffer) AsBytes() []byte {
-	return b.buf[:b.n]
+	return b.buf[:b.n:b.n]
 }
 
 // ToString returns a copy of the buffer's data as a string.

Original file line number	Diff line number	Diff line change
`@@ -61,8 +61,8 @@ func Open(name string) (*Store, error) {`
`61`	`61`	`return &Store{d}, nil`
`62`	`62`	`}`
`63`	`63`
`64`		`-// Has checks to see if the item exists in the config store, without allocating`
`65`		`-// any space to read it.`
	`64`	`+// Has returns true if the key exists in the config store, without allocating`
	`65`	`+// space to read a value.`
`66`	`66`	`func (s *Store) Has(key string) (bool, error) {`
`67`	`67`	`if s == nil {`
`68`	`68`	`return false, ErrKeyNotFound`
`@@ -86,7 +86,7 @@ func (s *Store) Has(key string) (bool, error) {`
`86`	`86`	`return v, nil`
`87`	`87`	`}`
`88`	`88`
`89`		`-// Get returns the item in the config store with the given key, as a byte slice.`
	`89`	`+// GetBytes returns the value in the config store for the given key, if it exists, as a byte slice.`
`90`	`90`	`func (s *Store) GetBytes(key string) ([]byte, error) {`
`91`	`91`	`if s == nil {`
`92`	`92`	`return nil, ErrKeyNotFound`
`@@ -106,16 +106,14 @@ func (s *Store) GetBytes(key string) ([]byte, error) {`
`106`	`106`	`return nil, err`
`107`	`107`	`}`
`108`	`108`	`}`
`109`		`-`
`110`	`109`	`return v, nil`
`111`	`110`	`}`
`112`	`111`
`113`		`-// Get returns the item in the config store with the given key.`
	`112`	`+// Get returns the value in the config store with the given key, if it exists.`
`114`	`113`	`func (s *Store) Get(key string) (string, error) {`
`115`	`114`	`buf, err := s.GetBytes(key)`
`116`	`115`	`if err != nil {`
`117`	`116`	`return "", err`
`118`	`117`	`}`
`119`		`-`
`120`	`118`	`return string(buf), nil`
`121`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ const bodySize = 64 * 1024`
`87`	`87`	`func TestRequestUpstreamBody(t *testing.T) {`
`88`	`88`	`body := make([]byte, bodySize)`
`89`	`89`	`for i := range body {`
`90`		`- body[i] = byte(i)`
	`90`	`+ body[i] = 'A'`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`b, err := fastly.NewHTTPBody()`
`@@ -124,15 +124,15 @@ func TestRequestUpstreamBody(t *testing.T) {`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`func requestUpstreamBody(t *testing.T, body io.Reader, size int, chunked bool) {`
`127`		`- req, err := fsthttp.NewRequest("POST", "https://http-me.glitch.me/?anything", body)`
	`127`	`+ req, err := fsthttp.NewRequest("POST", "https://http.edgecompute.app/anything/", body)`
`128`	`128`	`if err != nil {`
`129`	`129`	`t.Fatalf("NewRequest: %v", err)`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`req.Header.Set("Content-Type", "application/octet-stream")`
`133`	`133`	`req.CacheOptions.Pass = true`
`134`	`134`
`135`		`- resp, err := req.Send(context.Background(), "httpme")`
	`135`	`+ resp, err := req.Send(context.Background(), "httpedge")`
`136`	`136`	`if err != nil {`
`137`	`137`	`t.Fatalf("Send: %v", err)`
`138`	`138`	`}`
`@@ -142,8 +142,9 @@ func requestUpstreamBody(t *testing.T, body io.Reader, size int, chunked bool) {`
`142`	`142`	Headers map[string]string `json:"headers"`
`143`	`143`	`}`
`144`	`144`
`145`		`- if err := json.NewDecoder(resp.Body).Decode(&respData); err != nil {`
`146`		`- t.Fatalf("Decode: %v", err)`
	`145`	`+ gotBody := new(bytes.Buffer)`
	`146`	`+ if err := json.NewDecoder(io.TeeReader(resp.Body, gotBody)).Decode(&respData); err != nil {`
	`147`	`+ t.Fatalf("Decode: %v\nBody:\n%s", err, gotBody.String())`
`147`	`148`	`}`
`148`	`149`
`149`	`150`	`var teWant, clWant string`
Original file line number	Diff line number	Diff line change
`@@ -185,12 +185,11 @@ func IsFastlyError(err error) (FastlyStatus, bool) {`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`const (`
`188`		`- ipBufLen = 16 // known size for IP address buffers`
`189`		`- dnsBufLen = 256 // known size for "DNS" values, enough to hold the longest possible hostname or domain name`
`190`		`- dictionaryValueMaxLen = 8192 // known size for maximum config store value https://docs.fastly.com/en/guides/about-edge-dictionaries#limitations-and-considerations`
	`188`	`+ ipBufLen = 16 // known size for IP address buffers`
	`189`	`+ dnsBufLen = 256 // known size for "DNS" values, enough to hold the longest possible hostname or domain name`
`191`	`190`
`192`	`191`	`DefaultSmallBufLen = 128 // default size for "typically-small" values with variable sizes: HTTP methods, header names, tls protocol names, cipher suites`
`193`		`- DefaultMediumBufLen = 1024 // default size for values between small and large with variable sizes`
	`192`	`+ DefaultMediumBufLen = 1024 // default size for values between small and large, with variable sizes`
`194`	`193`	`DefaultLargeBufLen = 8192 // default size for "typically-large" values with variable sizes; header values, URLs.`
`195`	`194`	`)`
`196`	`195`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ func (b *WriteBuffer) NValue() Usize {`
`115`	`115`
`116`	`116`	`// AsBytes returns a slice of the buffer's data as a byte slice.`
`117`	`117`	`func (b *WriteBuffer) AsBytes() []byte {`
`118`		`- return b.buf[:b.n]`
	`118`	`+ return b.buf[:b.n:b.n]`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`// ToString returns a copy of the buffer's data as a string.`