Reimplemented JSMapFunction using js API

and removed JSRunner, JSServer since they are now unused.

Author: snej

js_map_fn.go

@@ -1,95 +1,51 @@
-//  Copyright 2012-Present Couchbase, Inc.
-//
-//  Use of this software is governed by the Business Source License included
-//  in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
-//  in that file, in accordance with the Business Source License, use of this
-//  software will be governed by the Apache License, Version 2.0, included in
-//  the file licenses/APL2.txt.
-
 package sgbucket
 
 import (
+	"context"
+	_ "embed"
+	"encoding/json"
 	"fmt"
 	"time"
 
-	"github.com/robertkrimen/otto"
+	"github.com/couchbase/sg-bucket/js"
 )
 
-const kTaskCacheSize = 4
-
-// A compiled JavaScript 'map' function, API-compatible with Couchbase Server 2.0.
-// Based on JSRunner, so this is not thread-safe; use its wrapper JSMapFunction for that.
-type jsMapTask struct {
-	JSRunner
-	output []*ViewRow
-}
-
-// Compiles a JavaScript map function to a jsMapTask object.
-func newJsMapTask(funcSource string, timeout time.Duration) (JSServerTask, error) {
-	mapper := &jsMapTask{}
-	err := mapper.Init(funcSource, timeout)
-	if err != nil {
-		return nil, err
-	}
-
-	// Implementation of the 'emit()' callback:
-	mapper.DefineNativeFunction("emit", func(call otto.FunctionCall) otto.Value {
-		key, err1 := call.ArgumentList[0].Export()
-		value, err2 := call.ArgumentList[1].Export()
-		if err1 != nil || err2 != nil {
-			panic(fmt.Sprintf("Unsupported key or value types: emit(%#v,%#v): %v %v", key, value, err1, err2))
-		}
-		mapper.output = append(mapper.output, &ViewRow{Key: key, Value: value})
-		return otto.UndefinedValue()
-	})
-
-	mapper.Before = func() {
-		mapper.output = []*ViewRow{}
-	}
-	mapper.After = func(result otto.Value, err error) (interface{}, error) {
-		output := mapper.output
-		mapper.output = nil
-		return output, err
-	}
-	return mapper, nil
-}
+//go:embed js_map_fn.js
+var kMapFunctionJSWrapper string
 
 //////// JSMapFunction
 
 // A thread-safe wrapper around a jsMapTask, i.e. a Couchbase-Server-compatible JavaScript
 // 'map' function.
 type JSMapFunction struct {
-	*JSServer
+	service *js.Service
+	timeout time.Duration
 }
 
-func NewJSMapFunction(fnSource string, timeout time.Duration) *JSMapFunction {
+func NewJSMapFunction(jsHost js.ServiceHost, fnSource string, timeout time.Duration) *JSMapFunction {
+	fnSource = fmt.Sprintf(kMapFunctionJSWrapper, fnSource)
 	return &JSMapFunction{
-		JSServer: NewJSServer(fnSource, timeout, kTaskCacheSize,
-			func(fnSource string, timeout time.Duration) (JSServerTask, error) {
-				return newJsMapTask(fnSource, timeout)
-			}),
+		service: js.NewService(jsHost, "Map", fnSource),
+		timeout: timeout,
 	}
 }
 
 // Calls a jsMapTask.
-func (mapper *JSMapFunction) CallFunction(doc string, docid string, vbNo uint32, vbSeq uint64) ([]*ViewRow, error) {
-	result1, err := mapper.Call(JSONString(doc), MakeMeta(docid, vbNo, vbSeq))
-	if err != nil {
-		return nil, err
-	}
-	rows := result1.([]*ViewRow)
-	for i, _ := range rows {
-		rows[i].ID = docid
+func (mapper *JSMapFunction) CallFunction(ctx context.Context, doc string, docid string, vbNo uint32, vbSeq uint64) ([]*ViewRow, error) {
+	if mapper.timeout > 0 {
+		newCtx, cancel := context.WithTimeout(ctx, mapper.timeout)
+		ctx = newCtx
+		defer cancel()
 	}
-	return rows, nil
-}
-
-// Returns a Couchbase-compatible 'meta' object, given a document ID
-func MakeMeta(docid string, vbNo uint32, vbSeq uint64) map[string]interface{} {
-	return map[string]interface{}{
-		"id":  docid,
-		"vb":  uint32(vbNo),  // convert back to well known type
-		"seq": uint64(vbSeq), // ditto
+	if output, err := mapper.service.Run(ctx, doc, docid, vbNo, vbSeq); err != nil {
+		return nil, err
+	} else if output == nil {
+		return nil, nil
+	} else if jsRows, ok := output.(string); !ok {
+		return nil, fmt.Errorf("JSMapFunction internal error: wrong type of result, %T", output)
+	} else {
+		var rows []*ViewRow
+		err = json.Unmarshal([]byte(jsRows), &rows)
+		return rows, err
 	}
-
 }

js_map_fn.js

@@ -0,0 +1,57 @@
+function() { var mapFn = %s;
+    // (put the interpolated map fn on line 1 so the line numbers in any syntax error will match)
+
+    //  Copyright 2023-Present Couchbase, Inc.
+    //
+    //  Use of this software is governed by the Business Source License included
+    //  in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+    //  in that file, in accordance with the Business Source License, use of this
+    //  software will be governed by the Apache License, Version 2.0, included in
+    //  the file licenses/APL2.txt.
+
+    if (typeof(mapFn) !== 'function') {
+        throw new Error('code does not compile to a function');
+    } else if (mapFn.length < 1 || mapFn.length > 3) {
+        throw new Error('map function must have 1-3 arguments');
+    }
+
+    var curDocID = undefined;
+    var result = undefined;
+
+    function emit(key, value) {
+        var row = {key: key, value: value, id: curDocID}
+        if (result === undefined) {
+            result = [row];
+        } else {
+            result.push(row);
+        }
+    }
+
+    var log = console.log;
+
+    {
+        /****  Variables used during the call but not visible to the map fn ****/
+
+        // For security reasons, prevent scripts from dynamically compiling code:
+        delete eval;
+        delete Function;
+
+        /**** The function that runs the map function ****/
+
+        return function (docJson, docid, vbNo, vbSeq) {
+            var doc = JSON.parse(docJson);
+            var meta = {
+                id: docid,
+                vb: vbNo,
+                seq: vbSeq
+            };
+            curDocID = docid;
+
+            result = undefined;
+
+            mapFn(doc, meta);
+
+            return result ? JSON.stringify(result) : undefined;
+        }
+    }
+}()

js_map_fn_test.go

@@ -9,82 +9,97 @@
 package sgbucket
 
 import (
+	"context"
 	"fmt"
 	"testing"
 
+	"github.com/couchbase/sg-bucket/js"
 	"github.com/stretchr/testify/assert"
 )
 
 // Just verify that the calls to the emit() fn show up in the output.
 func TestEmitFunction(t *testing.T) {
-	mapper := NewJSMapFunction(`function(doc) {emit("key", "value"); emit("k2","v2")}`, 0)
-	rows, err := mapper.CallFunction(`{}`, "doc1", 0, 0)
-	assertNoError(t, err, "CallFunction failed")
-	assert.Equal(t, 2, len(rows))
-	assert.Equal(t, &ViewRow{ID: "doc1", Key: "key", Value: "value"}, rows[0])
-	assert.Equal(t, &ViewRow{ID: "doc1", Key: "k2", Value: "v2"}, rows[1])
+	js.TestWithVMPools(t, 4, func(t *testing.T, pool *js.VMPool) {
+		mapper := NewJSMapFunction(pool, `function(doc) {emit("key", "value"); emit("k2","v2")}`, 0)
+		rows, err := mapper.CallFunction(pool.Context(), `{}`, "doc1", 0, 0)
+		assertNoError(t, err, "CallFunction failed")
+		assert.Equal(t, 2, len(rows))
+		assert.Equal(t, &ViewRow{ID: "doc1", Key: "key", Value: "value"}, rows[0])
+		assert.Equal(t, &ViewRow{ID: "doc1", Key: "k2", Value: "v2"}, rows[1])
+	})
 }
 
 func TestTimeout(t *testing.T) {
-	mapper := NewJSMapFunction(`function(doc) {while(true) {}}`, 1)
-	_, err := mapper.CallFunction(`{}`, "doc1", 0, 0)
-	assert.ErrorIs(t, err, ErrJSTimeout)
+	js.TestWithVMPools(t, 4, func(t *testing.T, pool *js.VMPool) {
+		mapper := NewJSMapFunction(pool, `function(doc) {while(true) {}}`, 1)
+		_, err := mapper.CallFunction(pool.Context(), `{}`, "doc1", 0, 0)
+		assert.ErrorIs(t, err, context.DeadlineExceeded)
+	})
 }
 
-func testMap(t *testing.T, mapFn string, doc string) []*ViewRow {
-	mapper := NewJSMapFunction(mapFn, 0)
-	rows, err := mapper.CallFunction(doc, "doc1", 0, 0)
+func testMap(t *testing.T, host js.ServiceHost, mapFn string, doc string) []*ViewRow {
+	mapper := NewJSMapFunction(host, mapFn, 0)
+	rows, err := mapper.CallFunction(host.Context(), doc, "doc1", 0, 0)
 	assertNoError(t, err, fmt.Sprintf("CallFunction failed on %s", doc))
 	return rows
 }
 
 // Now just make sure the input comes through intact
 func TestInputParse(t *testing.T) {
-	rows := testMap(t, `function(doc) {emit(doc.key, doc.value);}`,
-		`{"key": "k", "value": "v"}`)
-	assert.Equal(t, 1, len(rows))
-	assert.Equal(t, &ViewRow{ID: "doc1", Key: "k", Value: "v"}, rows[0])
+	js.TestWithVMPools(t, 4, func(t *testing.T, pool *js.VMPool) {
+		rows := testMap(t, pool, `function(doc) {emit(doc.key, doc.value);}`,
+			`{"key": "k", "value": "v"}`)
+		assert.Equal(t, 1, len(rows))
+		assert.Equal(t, &ViewRow{ID: "doc1", Key: "k", Value: "v"}, rows[0])
+	})
 }
 
 // Test different types of keys/values:
 func TestKeyTypes(t *testing.T) {
-	rows := testMap(t, `function(doc) {emit(doc.key, doc.value);}`,
-		`{"ID": "doc1", "key": true, "value": false}`)
-	assert.Equal(t, &ViewRow{ID: "doc1", Key: true, Value: false}, rows[0])
-	rows = testMap(t, `function(doc) {emit(doc.key, doc.value);}`,
-		`{"ID": "doc1", "key": null, "value": 0}`)
-	assert.Equal(t, &ViewRow{ID: "doc1", Key: nil, Value: float64(0)}, rows[0])
-	rows = testMap(t, `function(doc) {emit(doc.key, doc.value);}`,
-		`{"ID": "doc1", "key": ["foo", 23, []], "value": [null]}`)
-	assert.Equal(t, &ViewRow{
-		ID:    "doc1",
-		Key:   []interface{}{"foo", 23.0, []interface{}{}},
-		Value: []interface{}{nil},
-	}, rows[0])
-
+	js.TestWithVMPools(t, 4, func(t *testing.T, pool *js.VMPool) {
+		rows := testMap(t, pool, `function(doc) {emit(doc.key, doc.value);}`,
+			`{"ID": "doc1", "key": true, "value": false}`)
+		assert.Equal(t, &ViewRow{ID: "doc1", Key: true, Value: false}, rows[0])
+		rows = testMap(t, pool, `function(doc) {emit(doc.key, doc.value);}`,
+			`{"ID": "doc1", "key": null, "value": 0}`)
+		assert.Equal(t, &ViewRow{ID: "doc1", Key: nil, Value: float64(0)}, rows[0])
+		rows = testMap(t, pool, `function(doc) {emit(doc.key, doc.value);}`,
+			`{"ID": "doc1", "key": ["foo", 23, []], "value": [null]}`)
+		assert.Equal(t, &ViewRow{
+			ID:    "doc1",
+			Key:   []interface{}{"foo", 23.0, []interface{}{}},
+			Value: []interface{}{nil},
+		}, rows[0])
+	})
 }
 
 // Empty/no-op map fn
 func TestEmptyJSMapFunction(t *testing.T) {
-	mapper := NewJSMapFunction(`function(doc) {}`, 0)
-	rows, err := mapper.CallFunction(`{"key": "k", "value": "v"}`, "doc1", 0, 0)
-	assertNoError(t, err, "CallFunction failed")
-	assert.Equal(t, 0, len(rows))
+	js.TestWithVMPools(t, 4, func(t *testing.T, pool *js.VMPool) {
+		mapper := NewJSMapFunction(pool, `function(doc) {}`, 0)
+		rows, err := mapper.CallFunction(pool.Context(), `{"key": "k", "value": "v"}`, "doc1", 0, 0)
+		assertNoError(t, err, "CallFunction failed")
+		assert.Equal(t, 0, len(rows))
+	})
 }
 
 // Test meta object
 func TestMeta(t *testing.T) {
-	mapper := NewJSMapFunction(`function(doc,meta) {if (meta.id!="doc1") throw("bad ID");}`, 0)
-	rows, err := mapper.CallFunction(`{"key": "k", "value": "v"}`, "doc1", 0, 0)
-	assertNoError(t, err, "CallFunction failed")
-	assert.Equal(t, 0, len(rows))
+	js.TestWithVMPools(t, 4, func(t *testing.T, pool *js.VMPool) {
+		mapper := NewJSMapFunction(pool, `function(doc,meta) {if (meta.id!="doc1") throw("bad ID");}`, 0)
+		rows, err := mapper.CallFunction(pool.Context(), `{"key": "k", "value": "v"}`, "doc1", 0, 0)
+		assertNoError(t, err, "CallFunction failed")
+		assert.Equal(t, 0, len(rows))
+	})
 }
 
 // Test the public API
 func TestPublicJSMapFunction(t *testing.T) {
-	mapper := NewJSMapFunction(`function(doc) {emit(doc.key, doc.value);}`, 0)
-	rows, err := mapper.CallFunction(`{"key": "k", "value": "v"}`, "doc1", 0, 0)
-	assertNoError(t, err, "CallFunction failed")
-	assert.Equal(t, 1, len(rows))
-	assert.Equal(t, &ViewRow{ID: "doc1", Key: "k", Value: "v"}, rows[0])
+	js.TestWithVMPools(t, 4, func(t *testing.T, pool *js.VMPool) {
+		mapper := NewJSMapFunction(pool, `function(doc) {emit(doc.key, doc.value);}`, 0)
+		rows, err := mapper.CallFunction(pool.Context(), `{"key": "k", "value": "v"}`, "doc1", 0, 0)
+		assertNoError(t, err, "CallFunction failed")
+		assert.Equal(t, 1, len(rows))
+		assert.Equal(t, &ViewRow{ID: "doc1", Key: "k", Value: "v"}, rows[0])
+	})
 }