Remove WebSockets from Canvas expressions interpreter

package.json

@@ -215,7 +215,6 @@
     "rxjs": "^6.2.1",
     "script-loader": "0.7.2",
     "semver": "^5.5.0",
-    "socket.io": "^2.1.1",
     "stream-stream": "^1.2.6",
     "style-loader": "0.23.1",
     "tar": "2.2.0",

packages/kbn-interpreter/package.json

@@ -13,7 +13,6 @@
     "lodash": "npm:@elastic/lodash@3.10.1-kibana1",
     "lodash.clone": "^4.5.0",
     "scriptjs": "^2.5.8",
-    "socket.io-client": "^2.1.1",
     "uuid": "3.0.1"
   },
   "devDependencies": {

packages/kbn-interpreter/src/common/interpreter/socket_interpret.js → packages/kbn-interpreter/src/common/interpreter/interpreter_provider.js

@@ -33,7 +33,7 @@ import { interpretProvider } from './interpret';
   socket: the socket to communicate over
 */
 
-export function socketInterpreterProvider({
+export function interpreterProvider({
   types,
   functions,
   handlers,

packages/kbn-interpreter/src/public/index.js

@@ -18,6 +18,5 @@
  */
 
 export { loadBrowserRegistries } from './browser_registries';
-export { createSocket } from './socket';
 export { initializeInterpreter } from './interpreter';
 export { RenderFunctionsRegistry } from './render_functions_registry';

packages/kbn-interpreter/src/public/interpreter.js

@@ -17,55 +17,46 @@
  * under the License.
  */
 
-import { socketInterpreterProvider } from '../common/interpreter/socket_interpret';
+import { interpreterProvider } from '../common/interpreter/interpreter_provider';
 import { serializeProvider } from '../common/lib/serialize';
 import { createHandlers } from './create_handlers';
 
-export async function initializeInterpreter(socket, typesRegistry, functionsRegistry) {
-  let resolve;
-  const functionList = new Promise(_resolve => (resolve = _resolve));
-
-  const getInitializedFunctions = async () => {
-    return functionList;
-  };
+export async function initializeInterpreter(kfetch, typesRegistry, functionsRegistry) {
+  const serverFunctionList = await kfetch({ pathname: '/api/canvas/fns' });
+
+  // For every sever-side function, register a client-side
+  // function that matches its definition, but which simply
+  // calls the server-side function endpoint.
+  Object.keys(serverFunctionList).forEach(functionName => {
+    functionsRegistry.register(() => ({
+      ...serverFunctionList[functionName],
+      async fn(context, args) {
+        const types = typesRegistry.toJS();
+        const { serialize } = serializeProvider(types);
+        const result = await kfetch({
+          pathname: `/api/canvas/fns/${functionName}`,
+          method: 'POST',
+          body: JSON.stringify({
+            args,
+            context: serialize(context),
+          }),
+        });
+
+        return result;
+      },
+    }));
+  });
 
   const interpretAst = async (ast, context, handlers) => {
-    // Load plugins before attempting to get functions, otherwise this gets racey
-    const serverFunctionList = await functionList;
-    const interpretFn = await socketInterpreterProvider({
+    const interpretFn = await interpreterProvider({
       types: typesRegistry.toJS(),
-      handlers: { ...handlers, ...createHandlers(socket) },
+      handlers: { ...handlers, ...createHandlers() },
       functions: functionsRegistry.toJS(),
       referableFunctions: serverFunctionList,
-      socket: socket,
     });
     return interpretFn(ast, context);
   };
 
-  // Listen for interpreter runs
-  socket.on('run', ({ ast, context, id }) => {
-    const types = typesRegistry.toJS();
-    const { serialize, deserialize } = serializeProvider(types);
-    interpretAst(ast, deserialize(context)).then(value => {
-      socket.emit(`resp:${id}`, { value: serialize(value) });
-    });
-  });
-
-  // Create the function list
-  let gotFunctionList = false;
-  socket.once('functionList', (fl) => {
-    gotFunctionList = true;
-    resolve(fl);
-  });
-
-  const interval = setInterval(() => {
-    if (gotFunctionList) {
-      clearInterval(interval);
-      return;
-    }
-    socket.emit('getFunctionList');
-  }, 1000);
-
-  return { getInitializedFunctions, interpretAst };
+  return { interpretAst };
 }
 

packages/kbn-interpreter/src/public/interpreter.test.js

@@ -0,0 +1,75 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { initializeInterpreter } from './interpreter';
+
+jest.mock('../common/interpreter/interpreter_provider', () => ({
+  interpreterProvider: () => () => ({}),
+}));
+
+jest.mock('../common/lib/serialize', () => ({
+  serializeProvider: () => ({ serialize: () => ({}) }),
+}));
+
+jest.mock('./create_handlers', () => ({
+  createHandlers: () => ({}),
+}));
+
+describe('kbn-interpreter/interpreter', () => {
+  it('loads server-side functions', async () => {
+    const kfetch = jest.fn(async () => ({}));
+
+    await initializeInterpreter(kfetch, { toJS: () => ({}) }, ({ register: () => {} }));
+
+    expect(kfetch).toHaveBeenCalledTimes(1);
+    expect(kfetch).toHaveBeenCalledWith({ pathname: '/api/canvas/fns' });
+  });
+
+  it('registers client-side functions that pass through to the server', async () => {
+    const kfetch = jest.fn(async () => ({
+      hello: { name: 'hello' },
+      world: { name: 'world' },
+    }));
+
+    const register = jest.fn();
+
+    await initializeInterpreter(kfetch, { toJS: () => ({}) }, ({ register }));
+
+    expect(register).toHaveBeenCalledTimes(2);
+
+    const [ hello, world ] = register.mock.calls.map(([fn]) => fn());
+
+    expect(hello.name).toEqual('hello');
+    expect(typeof hello.fn).toEqual('function');
+    expect(world.name).toEqual('world');
+    expect(typeof world.fn).toEqual('function');
+
+    const context = {};
+    const args = { quote: 'All we have to decide is what to do with the time that is given us.' };
+
+    await hello.fn(context, args);
+
+    expect(kfetch).toHaveBeenCalledWith({
+      pathname: '/api/canvas/fns/hello',
+      method: 'POST',
+      body: JSON.stringify({ args, context }),
+    });
+  });
+
+});

src/legacy/core_plugins/interpreter/public/interpreter.js

@@ -18,7 +18,8 @@
  */
 
 
-import { initializeInterpreter, loadBrowserRegistries, createSocket } from '@kbn/interpreter/public';
+import { initializeInterpreter, loadBrowserRegistries } from '@kbn/interpreter/public';
+import { kfetch } from 'ui/kfetch';
 import chrome from 'ui/chrome';
 import { functions } from './functions';
 import { functionsRegistry } from './functions_registry';
@@ -46,9 +47,8 @@ let _interpreterPromise;
 
 const initialize = async () => {
   await loadBrowserRegistries(types, basePath);
-  const socket = await createSocket(basePath, functionsRegistry);
-  initializeInterpreter(socket, typesRegistry, functionsRegistry).then(interpreter => {
-    _resolve({ interpreter, socket });
+  initializeInterpreter(kfetch, typesRegistry, functionsRegistry).then(interpreter => {
+    _resolve({ interpreter });
   });
 };
 
@@ -64,8 +64,3 @@ export const interpretAst = async (...params) => {
   const { interpreter } = await getInterpreter();
   return await interpreter.interpretAst(...params);
 };
-
-export const updateInterpreterFunctions = async () => {
-  const { socket } =  await getInterpreter();
-  socket.emit('updateFunctionList');
-};

src/legacy/core_plugins/interpreter/server/routes/index.js

@@ -17,12 +17,12 @@
  * under the License.
  */
 
-import { socketApi } from './socket';
 import { translate } from './translate';
 import { plugins } from './plugins';
+import { registerServerFunctions } from './server_functions';
 
 export function routes(server) {
   plugins(server);
-  socketApi(server);
   translate(server);
+  registerServerFunctions(server);
 }