lzxhahaha / lzxhahaha.github.io-backup Goto Github PK

// 主进程中
const {ipcMain} = require('electron');
ipcMain.on('asynchronous-message', (event, arg) => {
  console.log(arg);  // prints "ping"
  event.sender.send('asynchronous-reply', 'pong');  // 异步返回
});

ipcMain.on('synchronous-message', (event, arg) => {
  console.log(arg);  // prints "ping"
  event.returnValue = 'pong';  // 同步返回
});

// 渲染进程中
const {ipcRenderer} = require('electron');
// 获取同步返回值
console.log(ipcRenderer.sendSync('synchronous-message', 'ping')); // prints "pong"

// 获取异步返回值
ipcRenderer.on('asynchronous-reply', (event, arg) => {
  console.log(arg); // prints "pong"
});
ipcRenderer.send('asynchronous-message', 'ping');

// 主进程
ipcMain.on('synchronous-message', (event, arg) => {
  // 各种操作...
  
  event.returnValue = 'pong';
});

// 渲染进程
const value = ipcRenderer.sendSync('synchronous-message', 'ping');

// 主进程
ipcMain.on('event', (e, data) => e.sender.send('event-response', data));

// 渲染进程
const foo = (data) => new Promise((resolve) => {
  ipcRenderer.send('event', data);
  ipcRenderer.on('event-response', (e, data) => resolve(data));
}

// 主进程
const listen = (eventName, handler) => {
  ipcMain.on(eventName, async (e, request) => {
    const { id, data } = request;
    const response = { code: 200 };
    try {
      response.data = await handler(data);
    } catch (err) {
      response.code = err.code || 500;
      response.data = { message: err.message || 'Main process error.' };
    }
    e.sender.send(`${eventName}_res_${id}`, response);
  });
};

// 渲染进程
const sendEvent = (eventName, options = {}) => {
  const { data } = options;

  const id = uuid.v1();
  const responseEvent = `${eventName}_res_${id}`;

  return new Promise((resolve, reject) => {
    // 这里使用 once 监听，响应到达后就销毁
    ipcRenderer.once(responseEvent, (event, response) => {
      if (response.code === 200) {
        resolve(response.data);
      } else {
        reject(response.data);
      }
    });
    // 监听建立之后再发送事件，稳一点
    ipcRenderer.send(eventName, { id, data });
  });
};

// 主进程
export default class LongEventServer {
  static listen(eventName, initHandler) {
    return new Promise((resolve) => {
      ipcMain.on(eventName, (e, args) => {
        const {id, data} = args;
        const server = new LongEventServer({
          eventName, id, data,
          sender: e.sender
        });
        initHandler(server);
        ipcMain.on(server._getEventName('start'), () => server.onStart(server.startData));
        ipcMain.on(server._getEventName('stop'), () => server.onStop());
        ipcMain.on(server._getEventName('disconnect'), () => {
          ['start', 'stop', 'disconnect'].forEach(el => ipcMain.removeAllListeners(server._getEventName(el)));
          server.onDisconnect();
        });
        resolve(server);
      })
    });
  }
  
  _getEventName(event) {
    return `${this.eventName}_${this.id}_${event}`;
  }
  
  // constructor/emit etc.
}

// 渲染进程
class LongEventClient {
  constructor(id, eventName, data) {
    this.id = id;
    this.eventName = eventName;
    this.startData = data;
  }

  _getEventName(event) {
    return `${this.eventName}_${this.id}_${event}`;
  }
  
  // other function like on(event) etc.
}

const sendLongEvent = (eventName, options = {}) => {
  const { data } = options;
  const id = uuid.v1();
  const client =  new LongEventClient(id, eventName, data);
  client.connect();
  return client;
};

// client.on('xxx') ...
// client.start()

// SyncLock 表定义
{
    // 加锁日期 YYYY-MM-DD
    date: {
        type: String,
        index: true,
        unique: true
    },
    // 1: 执行中;
    // 2: 执行失败;
    // 10: 执行完成;
    status: {
        type: Number,
        default: 1
    },
    // 重试次数
    retryTimes: {
        type: Number,
        default: 0
    },
    // 执行任务机器的hostname
    hostname: String
}