faas/ix-server/publisher.js

var Base = require('../base')
  , Connector = require('./connector')
  , fs = require('fs')
  , socketIoPkgJson = require('socket.io-client/package.json')

var debug = Base.logger('ix-publisher')

var exportInfo
var exportedProps
var deviceData = null
var _deviceData = false


exports.publishAndFindProxy = function(ixApiDir, cb_err_data){
  loadIxExports(ixApiDir, function(err, methodInfo){
    if (err) { cb_err_data(err); return }
    publishExportsAndGetProxy(methodInfo, cb_err_data)
  })
}

var withDeviceData = exports.withDeviceData = function(cb_err_data){
  if (_deviceData) { cb_err_data(null, deviceData); return }
  _deviceData = true;
  deviceData = { secret: Base.env.IX_DEVICE_SECRET }
  if (Base.env.IX_DEVICE_KEY) {
    console.log('DEVICE KEY: '+Base.env.IX_DEVICE_KEY)
    deviceData.key = Base.env.IX_DEVICE_KEY
    cb_err_data(null, deviceData)
  }
  else if (Base.env.IX_DEVICE_KEY_FILE === 'NONE') {
    cb_err_data(null, deviceData)
  }
  else {
    fs.readFile(Base.env.IX_DEVICE_KEY_FILE || '/factory/serial_number', { encoding: 'utf8' }, function(err,file){
      debug('withDeviceKey', err, file)
      var key = null
      if (file) {
        key = file.split(/\n/)[0].trim()
        console.log('DEVICE KEY: '+key)
      }
      deviceData.key = key
      cb_err_data(err, deviceData)
    })
  }
}

exports.ixCallNodejs = function(callData, responder){
  debug('ixCallNodejs', callData)
  var func = findProp(callData.api)
  if (func) {
    exports.ixCall(callData, responder, function(cd, clientCallback){
      var args = cd.args.slice(0)
      args.push(clientCallback)
      func.apply({}, args)
      ////
      // 2015-01-23:
      // Support coffeescript more easily, don't support return values.
      ////
      // if (returnVal !== void(0)) {
      //   // JSON doesn't easily differentiate between (undefined) and (null),
      //   // so we can't transmit (undefined) across the wire.
      //   // Therefore, use (null) as the "don't wait for the callback" value
      //   // (instead of using a special Base.IX_RETURN_UNDEFINED value, that
      //   // we try to convert to (undefined) when transmitting it back).
      //   //clientCallback(null, returnVal === Base.IX_RETURN_UNDEFINED ? void(0) : returnVal)
      //   // Always be async. http://nodejs.org/api/process.html#process_process_nexttick_callback
      //   process.nextTick(function(){ clientCallback(null, returnVal) })
      // }
    })
  }
  else {
    debug('ixCallNodejs', "Property not exported: '"+callData.api+"'.")
    throw 'Invalid function: '+callData.api
  }
}

exports.ixCall = function(callData, responder, invoker){
  var timeoutSecs = Number(callData.timeout || Base.env.IX_PROXY_TIMEOUT)
  if (!(timeoutSecs > 0)) { // careful about NaN / Number(undefined)
    timeoutSecs = 30 // default 30 seconds
  }
  var wait = timeoutSecs * 1000
  var timerOn = true
  var timer = setTimeout(function(){
    if (timerOn) {
      timerOn = false
      var err = 'TIMEOUT: Callback not invoked after '+(wait/1000)+' seconds, aborting. (Start server with the environment variable FAAS_IX_PROXY_TIMEOUT set to customize the timeout.)'
      debug('ixCall', err)
      responder({ reason: err })
    }
  }, wait)
  var clientCallback = function(err, data){
    debug('clientCallback', { err: err, data: data })
    if (err instanceof Error) {
      err = {
        name: err.name,
        message: err.message
      }
    }
    if (timerOn) {
      timerOn = false
      clearTimeout(timer)
      responder(err, data)
    }
  }
  try {
    invoker(callData, clientCallback)
  }
  catch(e){
    clientCallback(e)
  }
}

var loadIxExports = function(ixApiDir, cb_err_exportInfo){
  exportInfo = {}
  exportedProps = {}
  var ixDirname = ixApiDir || Base.env.IX_API_DIR || 'faas-ix'
  var ixDir = process.cwd()+'/'+ixDirname
  fs.readdir(ixDir, function(err, files){
    debug('readdir', { err: err, files: files })
    if (err) { cb_err_exportInfo(err, files); return }
    var file, path, fexports, modName, meta
    for (var i = 0; i < files.length; i++) {
      file = files[i]
      path = ixDir+'/'+file
      try {
        if (file.match(/\w$/)) { // Don't load auto-save files.
          fexports = require(path) // Supports files and module directories.
          debug('loadIxExports:file', file, fexports)
          modName = file
          modName = modName.replace(/\.(js|json|node)$/i, '')
          modName = modName.replace(/\W/g, '_')
          meta = exportInfo[modName]
          if (exportInfo[modName]) {
            console.log("Multiple definitions found for module '"+modName+"', only using definitions from file '"+meta.file+"' (discarding '"+file+"').")
          }
          else {
            exportInfo[modName] = { file: file, exports: metaForObj(fexports) }
            exportedProps[modName] = fexports
          }
        }
      }
      catch(e) {
        console.log('Unable to load module '+path+':', e)
      }
    }
    debug('loadIxExports:exportInfo', JSON.stringify(exportInfo))
    cb_err_exportInfo(null, exportInfo)
  })
}

var metaForObj = function(obj){
  var info
  var attName, att, metaInfo
  if (Base.utils.isFobject(obj)) {
    info = { isFunc: Base.utils.isFunction(obj) }
    if (Base.utils.isFunction(obj)) {
      info.isFunc = true // Top-level function.
    }
    for (attName in obj) { if (obj.hasOwnProperty(attName)) {
      if (!info.atts) { info.atts = {} }
      att = obj[attName]
      metaInfo = metaForObj(att)
      info.atts[attName] = metaInfo
    } }
  }
  else { // Non-object property.
    info = { value: obj }
  }
  // TODO: How to tell if it needs to be invoked with a callback? sync or async?
  return info
}

var publishExportsAndGetProxy = exports.publishExportsAndGetProxy = function(exportInfo, cb_err_data) {
  debug('sioVer', socketIoPkgJson.version)
  withDeviceData(function(err, device){
    Base.api({
      url: { pathname: '/ix/publishAndProxy', query: { sioVer: socketIoPkgJson.version } }
      , data: { exportInfo: exportInfo, device: device }
      , method: 'POST'
    }, cb_err_data)
  })
}

exports.publishHttpAndFindProxy = function(cb_err_data) {
  debug('sioVer', socketIoPkgJson.version)
  withDeviceData(function(err, device){
    Base.api({
      url: { pathname: '/ix/httpAndProxy', query: { sioVer: socketIoPkgJson.version } }
      , data: { device: device }
      , method: 'POST'
    }, cb_err_data)
  })
}

var findProp = function(name){
  var names = name.split('.')
  return findPropHelper(names, exportedProps)
}

var findPropHelper = function(names, props){
  var name = names.shift()
  var prop = props[name]
  if (prop && names.length > 0) {
    prop = findPropHelper(names, prop)
  }
  return prop
}