@live-change/online-service 0.2.29

package/index.js

@@ -0,0 +1,273 @@
+const http = require('http')
+const ReactiveDao = require("@live-change/dao")
+const ReactiveDaoWebsocket = require("@live-change/dao-websocket")
+const ReactiveServer = ReactiveDao.ReactiveServer
+const WebSocketServer = require('websocket').server
+
+const App = require("@live-change/framework")
+const app = App.app()
+
+const definition = app.createServiceDefinition({
+  name: 'online'
+})
+
+const config = definition.config
+const onlinePort = config.port || process.env.ONLINE_PORT || 8007
+const onlineHost = config.host || process.env.ONLINE_HOST || 'localhost'
+const onlineUrl = `ws://${onlineHost}:${onlinePort}/ws`
+
+const eventDelay = 2000
+const cacheDelay = 5000
+
+async function sendOnlineEvent(path) {
+  const type = path[0]
+  const params = path[1]
+  try {
+    if(type == 'object') {
+      const { group } = params
+      const triggerName = `${group}Online`
+      console.log("TRIGGER", triggerName)
+      await app.trigger({
+        ...params,
+        type: triggerName
+      })
+    } else if(type == 'user') {
+      const { group, user } = params
+      const triggerName = `user${group ? group.slice(0, 1).toUpperCase() + group.slice(1) : ''}Online`
+      console.log("TRIGGER", triggerName)
+      await app.trigger({
+        ...params,
+        type: triggerName
+      })
+    } else if(type == 'session') {
+      const { group, session } = params
+      const triggerName = `session${group ? group.slice(0, 1).toUpperCase() + group.slice(1) : ''}Online`
+      console.log("TRIGGER", triggerName)
+      await app.trigger({
+        ...params,
+        type: triggerName
+      })
+    }
+  } catch(error) {
+    console.error("ONLINE EVENT ERROR")
+  }
+}
+
+async function sendOfflineEvent(path) {
+  const type = path[0]
+  const params = path[1]
+  try {
+    if(type == 'object') {
+      const { group } = params
+      const triggerName = `${group}Offline`
+      console.log("TRIGGER", triggerName)
+      await app.trigger({
+        ...params,
+        type: triggerName
+      })
+    } else if(type == 'user') {
+      const { group, user } = params
+      const triggerName = `user${group ? group.slice(0, 1).toUpperCase() + group.slice(1) : ''}Offline`
+      console.log("TRIGGER", triggerName)
+      await app.trigger({
+        ...params,
+        type: triggerName
+      })
+    } else if(type == 'session') {
+      const { group, session } = params
+      const triggerName = `session${group ? group.slice(0, 1).toUpperCase() + group.slice(1) : ''}Offline`
+      console.log("TRIGGER", triggerName)
+      await app.trigger({
+        ...params,
+        type: triggerName
+      })
+    }
+  } catch(error) {
+    console.error("OFFLINE EVENT ERROR")
+  }
+}
+
+async function sendAllOfflineEvent() {
+  console.log("SEND ALL OFFLINE EVENT")
+  await app.trigger({
+    type: `allOffline`
+  })
+}
+
+const selfObservables = new Map()
+
+class SelfObservable extends ReactiveDao.Observable {
+  constructor(path) {
+    super()
+    this.path = path
+    this.disposeTimeout = null
+    this.onlineEventTimeout = null
+    this.offlineEventTimeout = null
+    this.lastEvent = null
+
+    console.log("PATH", this.path, "IS ONLINE")
+    this.setOnlineEventTimeout()
+  }
+  setOnlineEventTimeout() {
+    if(this.lastEvent == 'online') return
+    this.onlineEventTimeout = setTimeout(() => {
+      sendOnlineEvent(this.path)
+      this.lastEvent = 'online'
+      this.onlineEventTimeout = null
+    }, eventDelay)
+  }
+  setOfflineEventTimeout() {
+    if(this.lastEvent == 'offline') return
+    this.offlineEventTimeout = setTimeout(() => {
+      sendOfflineEvent(this.path)
+      this.lastEvent = 'offline'
+      this.offlineEventTimeout = null
+    }, eventDelay)
+  }
+  clearOnlineEventTimeout() {
+    if(this.onlineEventTimeout) {
+      clearTimeout(this.onlineEventTimeout)
+      this.onlineEventTimeout = null
+    }
+  }
+  clearOfflineEventTimeout() {
+    if(this.offlineEventTimeout) {
+      clearTimeout(this.offlineEventTimeout)
+      this.offlineEventTimeout = null
+    }
+  }
+  observe(observer) {
+    if(this.isDisposed()) this.respawn()
+    this.observers.push(observer)
+    this.fireObserver(observer, 'set', this.observers.length)
+  }
+  unobserve(observer) {
+    console.log("ONLINE UNOBSERVED")
+    this.observers.splice(this.observers.indexOf(observer), 1)
+    this.fireObservers('set', this.observers.length)
+    if(this.isUseless()) this.dispose()
+  }
+  dispose() {
+    this.disposed = true
+    console.log("PATH", this.path, "IS OFFLINE")
+    this.disposeTimeout = setTimeout(() => {
+      if(this.disposed) {
+        selfObservables.delete(JSON.stringify(this.path))
+      }
+    }, cacheDelay)
+    this.clearOnlineEventTimeout()
+    this.setOfflineEventTimeout()
+  }
+  respawn() {
+    if(this.disposeTimeout) {
+      clearTimeout(this.disposeTimeout)
+      this.disposeTimeout = null
+    }
+    this.disposed = false
+    this.clearOfflineEventTimeout()
+    this.setOnlineEventTimeout()
+    console.log("PATH", this.path, "IS ONLINE AGAIN")
+  }
+}
+
+function getSelfObservable(path) {
+  let observable = selfObservables.get(JSON.stringify(path))
+  if(observable) return observable
+  observable = new SelfObservable(path)
+  selfObservables.set(JSON.stringify(path), observable)
+  return observable
+}
+
+const onlineDao = {
+  observable([type, ...path]) {
+    console.log("OBSERVABLE", type, path)
+    if(type!='online') throw new Error("not found")
+    return getSelfObservable(path)
+  },
+  get([type, ...path]) {
+    console.log("GET", type, path)
+    if(type!='online') throw new Error("not found")
+    let observable = selfObservables.get(path)
+    return observable ? observable.observers.length : 0
+  },
+  dispose() {
+  }
+}
+
+const createDao = (clientSessionId) => {
+  console.log("ONLINE SERVICE DAO")
+  return onlineDao
+}
+
+definition.beforeStart(async service => {
+  await sendAllOfflineEvent()
+
+  const reactiveServer = new ReactiveServer(createDao)
+
+  const httpServer = http.createServer() // TODO: pure HTTP API
+  httpServer.listen(onlinePort)
+
+  let wsServer = new WebSocketServer({httpServer, autoAcceptConnections: false})
+  wsServer.on("request",(request) => {
+    let serverConnection = new ReactiveDaoWebsocket.server(request)
+    reactiveServer.handleConnection(serverConnection)
+  })
+
+  console.log(`server started at localhost:${onlinePort}`)
+})
+
+const onlineClient = new ReactiveDaoWebsocket.client("api-server-"+process.pid, onlineUrl)
+
+definition.view({
+  name: "session",
+  properties: {},
+  async get(params, { client, service }) {
+    const { session } = client
+    return onlineClient.get(['online', 'session', client.session, { ...params, session }])
+  },
+  async observable(params, { client, service }) {
+    const { session } = client
+    return onlineClient.observable(['online', 'session', { ...params, session }], ReactiveDao.ObservableValue)
+  }
+})
+
+definition.view({
+  name: "user",
+  properties: {},
+  async get(params, { client, service }) {
+    const { user } = client
+    return onlineClient.get(['online', 'user', { ...params, user }])
+  },
+  async observable(params, { client, service }) {
+    const { user } = client
+    return onlineClient.observable(['online', 'user', { ...params, user }], ReactiveDao.ObservableValue)
+  }
+})
+
+definition.view({
+  name: "self",
+  properties: {},
+  async get(params, { client, service }) {
+    return onlineClient.get(client.user
+        ? ['online', 'user', { ...params, user: client.user }]
+        : ['online', 'session', { ...params, session: client.session }])
+  },
+  async observable(params, { client, service }) {
+    return onlineClient.observable(client.user
+        ? ['online', 'user', { ...params, user: client.user }]
+        : ['online', 'session', { ...params, session: client.session }], ReactiveDao.ObservableValue)
+  }
+})
+
+definition.view({
+  name: "object",
+  properties: {},
+  async get(params, { client, service }) {
+    return onlineClient.get(['online', 'object', params])
+  },
+  async observable(params, { client, service }) {
+    return onlineClient.observable(['online', 'object', params], ReactiveDao.ObservableValue)
+  }
+})
+
+module.exports = definition

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@live-change/online-service",
+  "version": "0.2.29",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "setup": "INSTALL=true node index.js",
+    "test": "NODE_ENV=test blue-tape tests/*"
+  },
+  "author": "Michał Łaszczewski <michal@emikse.com>",
+  "license": "BSD-3-Clause",
+  "gitHead": "37d229ac05adf5e045ae3dcc826c6945d5dc3670"
+}