@lcap/nasl 2.22.0-beta.5 → 3.0.0-beta.1

package/src/breakpoint/store/core.ts

@@ -0,0 +1,411 @@
+import debounce from 'lodash/debounce';
+
+import { BaseNode, App } from '../../concepts';
+
+import {
+    STATUS_ENABLED,
+    STATUS_DELETED,
+    TARGET_BACKEND,
+    TARGET_FRONTEND,
+    EVENT_TYPE_OBJECT_INFO,
+    EVENT_TYPE_PAGE_INFO,
+    EVENT_TYPE_PARSE,
+    EVENT_TYPE_RESOLVE,
+    EVENT_TYPE_STEP_OVER,
+    EVENT_TYPE_BREAKPOINT,
+    EVENT_TYPE_SYNC_BREAKPOINTS,
+} from '../shared/constants';
+
+import * as socket from '../shared/socket';
+
+import { setCreate, setUpdate, setDelete } from '../shared/operations';
+import { getRealNode, traverseBreakpointOnNode, traverseBreakpointOnApp } from '../shared/utils';
+
+type Store = {
+    enable?: Boolean,
+    activePath?: string;
+    activeStackItem?: any;
+    echoStackItem?: any,
+    nodes?: BaseNode[];
+    stack?: any[],
+    connections?: string[];
+};
+
+type StepOverData = Parameters<typeof socket.emitToFrontend>[0];
+
+export const store: Store = {
+    enable: true,
+    nodes: [],
+    stack: [],
+    connections: [],
+    activePath: '',
+    activeStackItem: {},
+    echoStackItem: {},
+};
+
+Object.defineProperty(store, 'activePath', {
+    get: () => {
+        const { activeStackItem = {} } = store;
+        const { operation = {} } = activeStackItem;
+        const { path = '' } = operation;
+
+        return path;
+    },
+});
+
+const isUseful = (node: BaseNode) => {
+    if (!node) {
+        return false;
+    }
+
+    const { app, nodePath } = (node as any);
+
+    if (!app || !nodePath) {
+        return false;
+    }
+
+    return app.findNodeByPath(nodePath);
+};
+
+const clean = debounce(() => {
+    const set = new Set();
+
+    for (let i = 0; i < store.nodes.length; i += 1) {
+        const current = store.nodes[i];
+        const { id } = current;
+
+        const repeated = set.has(id);
+        const useless = !isUseful(current);
+
+        if (useless || repeated) {
+            store.nodes.splice(i, 1);
+            i -= 1;
+        } else {
+            set.add(id);
+        }
+    }
+}, 300);
+
+export const syncBreakpointsToFrontend = () => {
+    const { nodes = [] } = store;
+
+    const paths = nodes.map((item) => item.nodePath);
+
+    socket.emitToFrontend({
+        eventType: EVENT_TYPE_SYNC_BREAKPOINTS,
+        paths,
+    });
+};
+
+const creater = (node: BaseNode) => {
+    if (!node?.breakpoint) {
+        return;
+    }
+
+    store.nodes.push(node);
+    clean();
+
+    syncBreakpointsToFrontend();
+};
+
+const deleter = (node: BaseNode) => {
+    const index = store.nodes.indexOf(node);
+    index > -1 && store.nodes.splice(index, 1);
+
+    syncBreakpointsToFrontend();
+};
+
+const updater = (node: BaseNode) => {
+    if (!node) {
+        return;
+    }
+
+    const { breakpoint } = node;
+    const { nodes = [] } = store;
+
+    const included = nodes.includes(node);
+
+    if (breakpoint) {
+        !included && creater(node);
+    } else {
+        included && deleter(node);
+    }
+};
+
+setCreate(creater);
+setUpdate(updater);
+setDelete(deleter);
+
+export const addBreakpointNode = (node: BaseNode) => {
+    node = getRealNode(node);
+
+    if (!node) {
+        return;
+    }
+
+    node.update({ breakpoint: STATUS_ENABLED });
+    socket.emitToBackend({
+        eventType: EVENT_TYPE_BREAKPOINT,
+        breakpoint: {
+            path: node.nodePath,
+            breakpointStatus: STATUS_ENABLED,
+        },
+    });
+
+    creater(node);
+};
+
+export const removeBreakpointNode = (node: BaseNode) => {
+    node = getRealNode(node);
+
+    if (!node) {
+        return;
+    }
+
+    node.update({ breakpoint: null });
+    socket.emitToBackend({
+        eventType: EVENT_TYPE_BREAKPOINT,
+        breakpoint: {
+            path: node.nodePath,
+            breakpointStatus: STATUS_DELETED,
+        },
+    });
+
+    deleter(node);
+};
+
+export const addBreakpointNodesFromNode = (source: BaseNode) => {
+    traverseBreakpointOnNode(source, creater);
+};
+
+export const addBreakpointNodesFromApp = (source: App) => {
+    store.nodes = [];
+    traverseBreakpointOnApp(source, creater);
+};
+
+let temporaryNodes: BaseNode[] = [];
+
+export const recoverBreakpointAfterTemporary = () => {
+    temporaryNodes.forEach((node) => {
+        if (node) {
+            node.breakpoint = STATUS_ENABLED;
+        }
+    });
+};
+
+export const removeBreakpointForTemporary = async () => {
+    temporaryNodes = store.nodes || [];
+    temporaryNodes.forEach((node) => {
+        if (node && 'breakpoint' in node) {
+            delete node.breakpoint;
+        }
+    });
+
+    await Promise.resolve(temporaryNodes);
+    recoverBreakpointAfterTemporary();
+};
+
+export const findFromStack = (targetPath = store.activePath) => {
+    const { stack = [], activeStackItem = {} } = store;
+    const { operation: { path: activeStackItemPath = '' } = {} } = activeStackItem;
+
+    if (activeStackItemPath === targetPath) {
+        return activeStackItem;
+    }
+
+    return stack.find((item = {}) => {
+        const { operation: { path = '' } = {} } = item;
+
+        return targetPath === path;
+    });
+};
+
+export const resolveBreakpointToBackend = (path = store.activePath) => {
+    const eventType = EVENT_TYPE_RESOLVE;
+    const data = { eventType, path };
+
+    path && socket.emitToBackend(data);
+};
+
+export const resolveBreakpointToFrontend = (path = store.activePath) => {
+    const eventType = EVENT_TYPE_RESOLVE;
+    const data = { eventType, path };
+
+    path && socket.emitToFrontend(data);
+};
+
+export const resolveByPath = (path = store.activePath) => {
+    const { activePath, stack = [] } = store;
+
+    const found = findFromStack(path);
+    const nextStack = stack.filter((item) => item !== found);
+
+    if (activePath === path) {
+        store.activeStackItem = nextStack[0];
+    }
+
+    store.stack = nextStack;
+};
+
+export const resolveBreakpoint = (path = store.activePath) => {
+    const found = findFromStack();
+
+    if (!found) {
+        return;
+    }
+
+    const { target } = found;
+
+    switch (target) {
+        case TARGET_BACKEND: {
+            resolveBreakpointToBackend(path);
+            break;
+        }
+        case TARGET_FRONTEND: {
+            resolveBreakpointToFrontend(path);
+            break;
+        }
+    }
+
+    store.echoStackItem = found;
+    resolveByPath();
+};
+
+const stepOverBreakpointToBackend = () => {
+    const { activePath } = store;
+
+    activePath && socket.emitToBackend({
+        eventType: EVENT_TYPE_STEP_OVER,
+        path: store.activePath,
+    });
+};
+
+const stepOverBreakpointToFrontend = (data: StepOverData = {}) => {
+    const { activePath } = store;
+
+    activePath && socket.emitToFrontend({
+        eventType: EVENT_TYPE_STEP_OVER,
+        path: store.activePath,
+        ...data,
+    });
+};
+
+export const stepOverBreakpoint = (data: StepOverData = {}) => {
+    const found = findFromStack();
+
+    if (!found) {
+        return;
+    }
+
+    const { target } = found;
+
+    switch (target) {
+        case TARGET_BACKEND: {
+            stepOverBreakpointToBackend();
+            break;
+        }
+        case TARGET_FRONTEND: {
+            stepOverBreakpointToFrontend(data);
+            break;
+        }
+    }
+
+    store.echoStackItem = found;
+    resolveByPath();
+};
+
+const CACHE_KEY = 'activePath';
+const cacher = new Map();
+
+const clearBeforeEmit = () => {
+    const { activePath: storeActivePath } = store;
+    const cacheActivePath = cacher.get(CACHE_KEY);
+
+    const empty = !cacheActivePath;
+    const different = storeActivePath !== cacheActivePath;
+
+    empty && cacher.clear();
+    different && cacher.clear();
+
+    cacher.set(CACHE_KEY, storeActivePath);
+};
+
+const emitToBackendWithCache = (source: Record<string, any> = {}) => {
+    clearBeforeEmit();
+
+    const key = JSON.stringify(source);
+    const cache = cacher.get(key) || socket.emitToBackend(source);
+
+    cacher.set(key, cache);
+    return cache;
+};
+
+export const fetchBackendPage = (source: Record<string, any> = {}) => emitToBackendWithCache({
+    eventType: EVENT_TYPE_PAGE_INFO,
+    ...source,
+});
+
+export const fetchBackendObject = (source: Record<string, any> = {}) => emitToBackendWithCache({
+    eventType: EVENT_TYPE_OBJECT_INFO,
+    ...source,
+});
+
+let variableNodes: BaseNode[] = [];
+let variablesPromise: Promise<any>;
+let resolveVariablesPromise: (arg: any) => void;
+
+const nodeToCode = (node: BaseNode) => {
+    let code;
+
+    try {
+        if ('toJS' in node) {
+            code = (node as any).toJS();
+        }
+    } catch (e) {
+        console.error(e);
+        code = '';
+    }
+
+    return code;
+};
+
+const fetchVariables = debounce(async () => {
+    const { activePath } = store;
+
+    const resolve = resolveVariablesPromise;
+    const codes = variableNodes.map(nodeToCode);
+
+    variableNodes = [];
+    variablesPromise = undefined;
+    resolveVariablesPromise = undefined;
+
+    const result = await socket.emitToFrontend({
+        eventType: EVENT_TYPE_PARSE,
+        path: activePath,
+        codes,
+    });
+
+    resolve && resolve(result);
+}, 0, { leading: false, trailing: true });
+
+const getVariablesPromise = () => {
+    variablesPromise = variablesPromise || new Promise((resolve) => {
+        resolveVariablesPromise = resolve;
+    });
+
+    fetchVariables();
+    return variablesPromise;
+};
+
+export const fetchFrontendVariable = async (node: BaseNode) => {
+    const { length } = variableNodes;
+
+    variableNodes = variableNodes.concat(node);
+
+    const promise = getVariablesPromise();
+    const result = await promise;
+
+    return result && result[length];
+};
+
+export default store;

package/src/breakpoint/store/dock.ts

@@ -0,0 +1,166 @@
+import {
+    EVENT_DISCONNECT,
+    EVENT_RECONNECT,
+    TARGET_BACKEND,
+    TARGET_FRONTEND,
+    EVENT_TYPE_RESOLVE,
+    EVENT_TYPE_BREAKPOINT,
+    RESPONSE_TYPE_DEBUG_INFO,
+    RESPONSE_TYPE_CONNECTION_INFO,
+    CONNECTION_NAME_BACKEND,
+    CONNECTION_NAME_FRONTEND,
+    CONNECTION_STATUS_CONNECTED,
+    CONNECTION_STATUS_DISCONNECTED,
+} from '../shared/constants';
+
+import * as socket from '../shared/socket';
+
+import {
+    store,
+    findFromStack,
+    resolveByPath,
+    resolveBreakpoint,
+    syncBreakpointsToFrontend,
+} from './core';
+
+type Source = {
+    target?: string,
+    operation?: {
+        threadId?: number,
+    },
+};
+
+type ForBreakpoint = (target: string) => Parameters<typeof socket.on>[1];
+
+const isMatchStepOver = (source: Source = {}) => {
+    const { echoStackItem = {} } = store;
+    const {
+        target,
+        operation: { threadId = 0 } = {},
+    } = echoStackItem;
+    const {
+        target: sourceTarget,
+        operation: { threadId: sourceThreadId = 0 } = {},
+    } = source;
+
+    const a = [target, threadId];
+    const b = [sourceTarget, sourceThreadId];
+
+    return a.every((x, i) => a[i] === b[i]);
+};
+
+const forBreakpoint: ForBreakpoint = (target) => (data = {}) => {
+    const { enable, activePath, activeStackItem } = store;
+    const { path } = data;
+
+    const current = { target, operation: data };
+    const matched = isMatchStepOver(current);
+
+    if (matched) {
+        store.stack.unshift(current);
+        store.activeStackItem = current;
+        store.echoStackItem = undefined;
+    } else {
+        store.stack.push(current);
+        store.activeStackItem = activePath ? activeStackItem : current;
+    }
+
+    !enable && path && resolveBreakpoint(path);
+};
+
+// 前端代码执行到断点发送过来
+socket.on(EVENT_TYPE_BREAKPOINT, forBreakpoint(TARGET_FRONTEND));
+
+// 后端代码执行到断点发送过来
+socket.on(RESPONSE_TYPE_DEBUG_INFO, forBreakpoint(TARGET_BACKEND));
+
+// 建立连接时
+socket.on(RESPONSE_TYPE_CONNECTION_INFO, (data = {}) => {
+    const { connectionName, connectionStatus } = data;
+
+    const isFrontend = connectionName === CONNECTION_NAME_FRONTEND;
+    const isConnected = connectionStatus === CONNECTION_STATUS_CONNECTED;
+
+    if (isFrontend && isConnected) {
+        syncBreakpointsToFrontend();
+    }
+});
+
+const cleanStackWhenDisconnect = (target: string) => {
+    if (!target) {
+        return;
+    }
+
+    const found = findFromStack();
+
+    const { stack = [] } = store;
+    const filter = (item: any = {}) => item.target !== target;
+
+    store.stack = stack.filter(filter);
+
+    const useful = store.stack.includes(found);
+
+    if (useful) {
+        return;
+    }
+
+    store.activeStackItem = store.stack[0];
+};
+
+// 连接发生变化时
+socket.on(RESPONSE_TYPE_CONNECTION_INFO, (data = {}) => {
+    const { connections = [] } = store;
+    const { connectionName, connectionStatus } = data;
+
+    switch (connectionStatus) {
+        case CONNECTION_STATUS_CONNECTED: {
+            store.connections.push(connectionName);
+            break;
+        }
+        case CONNECTION_STATUS_DISCONNECTED: {
+            const filter = (item: string) => item !== connectionName;
+            store.connections = connections.filter(filter);
+
+            switch (connectionName) {
+                case CONNECTION_NAME_BACKEND: {
+                    cleanStackWhenDisconnect(TARGET_BACKEND);
+                    break;
+                }
+                case CONNECTION_NAME_FRONTEND: {
+                    cleanStackWhenDisconnect(TARGET_FRONTEND);
+                    break;
+                }
+            }
+            break;
+        }
+    }
+});
+
+// 前端手动释放断点
+socket.on(EVENT_TYPE_RESOLVE, (data = {}) => {
+    const { path } = data;
+
+    path && resolveByPath(path);
+});
+
+const cleanStore = () => {
+    store.stack = [];
+    store.connections = [];
+    store.activeStackItem = {};
+};
+
+socket.on(EVENT_DISCONNECT, cleanStore);
+socket.on(EVENT_RECONNECT, cleanStore);
+
+socket.setBackendPolyfillGetter(() => {
+    const found = findFromStack();
+
+    if (!found) {
+        return;
+    }
+
+    const { operation = {} } = found;
+    const { variables, ...rest } = operation;
+
+    return rest;
+});

package/src/breakpoint/store/index.ts

@@ -0,0 +1,2 @@
+import './dock';
+export * from './core';

package/src/breakpoint/types/index.d.ts

@@ -0,0 +1,19 @@
+declare module 'socket.io-client' {
+    export interface Socket {
+        connected: boolean;
+        on: (...args: any[]) => void;
+        emit: (...args: any[]) => void;
+        close: (...args: any[]) => void;
+        disconnect: (...args: any[]) => void;
+    }
+
+    export type IO = (...args: any[]) => any;
+
+    const io: IO = () => ({});
+
+    export default io;
+}
+
+declare module 'lodash/debounce' {
+    export default (...args: any[]) => any;
+}

package/src/common/BaseNode.ts

@@ -16,6 +16,7 @@ import { ViewElement, App, TypeAnnotation } from '..';
 import * as jsoner from '../service/storage/jsoner';
 
 import { sentryMonitorNaslNode } from '../sentry';
+import operations from '../breakpoint/shared/operations';
 
 /**
  * 顶点类
@@ -59,6 +60,15 @@ export class BaseNode extends EventEmitter {
     workingCopy: object = undefined;
     @property()
     branch: object = undefined;
+    /**
+     * 断点状态
+     * undefined ==> 未设置
+     * null ==> 已删除
+     * 'ENABLED' ==> 启用断点
+     * 'DISABLED' ==> 禁用断点
+     */
+    @property()
+    breakpoint: 'ENABLED' | 'DISABLED' | null | undefined = undefined;
     /**
      * 父节点
      */
@@ -170,6 +180,13 @@ export class BaseNode extends EventEmitter {
         this.on('create', this.genActionListener);
         this.on('delete', this.genActionListener);
         this.on('update', this.genActionListener);
+
+        /**
+         * 监听action，delete，update事件
+         */
+        this.on('create', () => operations.create(this));
+        this.on('delete', () => operations.delete(this));
+        this.on('update', () => operations.update(this));
     }
 
     // static constructorName = 'BaseNode'
@@ -203,6 +220,7 @@ export class BaseNode extends EventEmitter {
                     throw e;
             }
         });
+        operations.create(this);
         // if (config.storage.protocol === 'http' && loadThen[source.concept as 'App' | 'View']) {
         //     const { childNodes } = loadThen[source.concept as 'App' | 'View'] || {};
         //     const queryList = childNodes.map(({ field, concept }) => {
@@ -1045,7 +1063,7 @@ export class BaseNode extends EventEmitter {
     }
     get isTreeLeaf() {
         if (this.concept === 'EntityProperty' || this.concept === 'InterfaceParam' || this.concept === 'Param'
-         || this.concept === 'Return' || this.concept === 'StructureProperty' || this.concept === 'Variable') {
+            || this.concept === 'Return' || this.concept === 'StructureProperty' || this.concept === 'Variable') {
             if ((this as any).typeAnnotation || (this.__TypeAnnotation && this.parentKey === 'virtualParams')) {
                 return !this.hasChildren;
             } else {