search

Author: chenyunan

app/CodingSDK.js

@@ -10,7 +10,7 @@ import * as Modal from './components/Modal/actions'
 import * as SideBarActions from './components/Panel/SideBar/actions'
 import { notify, NOTIFY_TYPE } from './components/Notification/actions'
 import api from '../app/backendAPI'
-import { closeWebsocketClient, closeTtySocketClient } from '../app/backendAPI/workspaceAPI'
+import { closeWebsocketClient, closeTtySocketClient, closeSearchWebsocketClient } from '../app/backendAPI/workspaceAPI'
 import * as Panel from './components/Panel/actions'
 import * as File from './commons/File'
 import initializeState from './containers/Initialize/state'
@@ -62,7 +62,8 @@ export default class {
   get socketManager () {
     return ({
       closeWebsocketClient,
-      closeTtySocketClient
+      closeTtySocketClient,
+      closeSearchWebsocketClient
     })
   }
 

app/backendAPI/searchAPI.js

@@ -0,0 +1,26 @@
+import { SearchSocketClient } from './websocketClients'
+import config from 'config';
+
+export function searchWorkspaceUp() {
+    SearchSocketClient.$$singleton.send(`/app/ws/up`, {spaceKey: config.spaceKey});
+}
+
+export function searchWorkspaceDown() {
+    SearchSocketClient.$$singleton.send(`/app/ws/down`, {spaceKey: config.spaceKey});
+}
+
+export function searchWorkspaceStatus() {
+    SearchSocketClient.$$singleton.send(`/app/ws/status`, {spaceKey: config.spaceKey});
+}
+
+export function searchString(searching, randomKey) {
+    SearchSocketClient.$$singleton.send(`/app/search/string`, {spaceKey: config.spaceKey, randomKey: randomKey}, JSON.stringify(searching));
+}
+
+export function searchPattern(searching, randomKey) {
+    SearchSocketClient.$$singleton.send(`/app/search/pattern`, {spaceKey: config.spaceKey, randomKey: randomKey}, JSON.stringify(searching));
+}
+
+export function searchInterrupt(taskId) {
+    SearchSocketClient.$$singleton.send(`/app/search/interrupt`, {spaceKey: config.spaceKey}, taskId);
+}

app/backendAPI/websocketClients.js

@@ -5,6 +5,7 @@ import emitter, * as E from 'utils/emitter'
 import config from 'config'
 import { autorun, runInAction } from 'mobx'
 import { notify, NOTIFY_TYPE } from '../components/Notification/actions'
+import * as searchAPI from 'backendAPI/searchAPI'
 
 const log = console.log || (x => x)
 const warn = console.warn || (x => x)
@@ -93,6 +94,9 @@ class FsSocketClient {
     if (TtySocketClient.$$singleton) {
       TtySocketClient.$$singleton.close();
     }
+    if(SearchSocketClient.$$singleton) {
+      SearchSocketClient.$$singleton.close();
+    }
   }
 }
 
@@ -179,4 +183,104 @@ class TtySocketClient {
   }
 }
 
-export { FsSocketClient, TtySocketClient }
+class SearchSocketClient {
+  constructor () {
+      if (SearchSocketClient.$$singleton) return SearchSocketClient.$$singleton
+
+      const wsUrl = config.wsURL
+      const firstSlashIdx = wsUrl.indexOf('/', 8)
+      const [host, path] = firstSlashIdx === -1 ? [wsUrl, ''] : [wsUrl.substring(0, firstSlashIdx), wsUrl.substring(firstSlashIdx)]
+      
+      const url = `${host}:8066/search/sockjs`
+
+      this.sockJSConfigs = [url, {}, {server: `${config.spaceKey}`, transports: 'websocket'}]
+
+      this.backoff = getBackoff({
+        delayMin: 1500,
+        delayMax: 10000,
+      })
+      this.maxAttempts = 5
+  
+      SearchSocketClient.$$singleton = this
+      emitter.on(E.SOCKET_RETRY, () => {
+        this.reconnect()
+      })
+  }
+
+  connect () {
+    if (!this.socket || !this.stompClient) {
+      this.socket = new SockJS(...this.sockJSConfigs)
+      this.stompClient = Stomp.over(this.socket)
+      this.stompClient.debug = false // stop logging PING/PONG
+    }
+    const success = () => {
+      runInAction(() => config.searchSocketConnected = true)
+      this.backoff.reset()
+      this.successCallback(this.stompClient)
+    }
+    const error = (frame) => {
+      if (this.shouldClose) {
+        this.shouldClose = false;
+        return;
+      }
+      log('[SEARCH Socket] SearchSocket error', this.socket)
+      switch (this.socket.readyState) {
+        case SockJS.CLOSING:
+        case SockJS.CLOSED:
+          runInAction(() => config.searchSocketConnected = false)
+          this.reconnect()
+          break
+        case SockJS.OPEN:
+          log('FRAME ERROR', frame)
+          break
+        default:
+      }
+      this.errorCallback(frame)
+    }
+
+    this.stompClient.connect({}, success, error)
+  }
+
+  reconnect () {
+    if (config.searchSocketConnected) return
+    log(`[SEARCH Socket] reconnect searchSocket ${this.backoff.attempts}`)
+    // unset this.socket
+    this.socket = undefined
+    if (this.backoff.attempts <= this.maxAttempts) {
+      const retryDelay = this.backoff.duration()
+      log(`Retry after ${retryDelay}ms`)
+      const timer = setTimeout(
+        this.connect.bind(this)
+      , retryDelay)
+    } else {
+      // must emit ，ops correct?
+      // emitter.emit(E.SOCKET_TRIED_FAILED)
+      notify({ message: i18n`global.onSocketError`, notifyType: NOTIFY_TYPE.ERROR })
+      this.backoff.reset()
+      warn('Sock connected failed, something may be broken, reload page and try again')
+    }
+  }
+
+  close () {
+    const self = this
+    if (config.searchSocketConnected) {
+      searchAPI.searchWorkspaceDown();
+      self.shouldClose = true;
+      self.socket.close();
+      // must emit ???
+      // emitter.emit(E.SOCKET_TRIED_FAILED);
+      runInAction(() => config.searchSocketConnected = false);
+    }
+  }
+
+  subscribe = (topic, process) => {
+      this.stompClient.subscribe(topic, process);
+  }
+
+  send = (mapping, headers, data) => {
+      this.stompClient.send(mapping, headers, data);
+  }
+}
+
+
+export { FsSocketClient, TtySocketClient, SearchSocketClient }

app/backendAPI/workspaceAPI.js

@@ -1,10 +1,13 @@
 import config from '../config'
 import { request } from '../utils'
-import { FsSocketClient, TtySocketClient } from './websocketClients'
+import { FsSocketClient, TtySocketClient, SearchSocketClient } from './websocketClients'
 
 let connectedResolve
 export const fsSocketConnectedPromise = new Promise((rs, rj) => connectedResolve = rs)
 
+let searchConnectedResolve;
+export const searchSocketConnectedPromise = new Promise((rs, rj) => searchConnectedResolve = rs);
+
 export function isWorkspaceExist () {
   return request.get(`/workspaces/${config.spaceKey}`)
   .catch(() => false)
@@ -41,6 +44,18 @@ export function connectWebsocketClient () {
   })
 }
 
+export function connectSearchWebsocketClient() {
+  return new Promise((resolve) => {
+    const searchSocketClient = new SearchSocketClient();
+    searchSocketClient.successCallback = function(stompClient) {
+      searchConnectedResolve(stompClient);
+      resolve(true);
+    }
+    searchSocketClient.errorCallback = function(error) {}
+    searchSocketClient.connect();
+  })
+}
+
 export function closeWebsocketClient () {
   const fsSocketClient = new FsSocketClient()
   fsSocketClient.close()
@@ -51,6 +66,11 @@ export function closeTtySocketClient () {
   ttySocketClient.close()
 }
 
+export function closeSearchWebsocketClient() {
+  const searchSocketClient = new SearchSocketClient();
+  searchSocketClient.close();
+}
+
 export function getSettings () {
   return request.get(`/workspaces/${config.spaceKey}/settings?base64=false`).then(({ content = {} }) => JSON.parse(content))
 }

app/commons/Search/action.js

@@ -0,0 +1,58 @@
+import * as api from 'backendAPI/searchAPI'
+import state from './state'
+
+function searchUp() {
+  if(!state.ws.status) {
+    state.ws.name = spaceKey;
+    api.searchWorkspaceUp();
+  }
+}
+
+function searchDown() {
+  if(state.ws.status) {
+    api.searchWorkspaceDown();
+  }
+}
+
+function searchStatus() {
+  api.searchWorkspaceStatus();
+}
+
+function searchString() {
+  if(state.ws.status) {
+    commonSearch();
+    api.searchString(state.searching, state.searched.randomKey);
+  }
+}
+
+function searchPattern() {
+  if(state.ws.status) {
+    commonSearch();
+    api.searchPattern(state.searching, state.searched.randomKey);
+  }
+}
+
+function commonSearch() {
+  if(!state.searched.end) {
+    api.searchInterrupt(state.searched.taskId);
+  }
+  if(state.searched.taskId != null) {
+    state.searched.former.taskId = state.searched.taskId
+    state.searched.former.results = state.searched.results.splice(0, state.searched.results.length);
+    state.searched.taskId = ''
+  }
+  state.searched.randomKey = randomForOne()
+}
+
+function searchInterrupt() {
+  if(state.ws.status 
+      && !state.searched.end) {
+    api.searchInterrupt(state.searched.taskId);
+  }
+}
+
+function randomForOne() {
+  return Math.random().toString(36)
+}
+
+export { searchUp, searchDown, searchStatus, searchString, searchPattern, searchInterrupt }

app/commons/Search/state.js

@@ -0,0 +1,36 @@
+import { observable } from 'mobx'
+
+export const ws = observable({
+  name: '',
+  status: false
+})
+
+export const searching = observable({
+  pattern: '',
+  path: '',
+  caseSensitive: false,
+  word: false,
+  isPattern: false,
+  singleFork: false
+})
+
+export const searched = observable({
+  taskId: '',
+  randomKey: '',
+  pattern: false,
+  message: '',
+  results: [],
+  end: true,
+  former: {
+      taskId: '',
+      results: []
+  }
+})
+
+const state = {
+  ws,
+  searching,
+  searched
+}
+
+export default state;