Mesh Debug

0_base.js

'use strict'

var Seneca = require('seneca')
var Mesh = require('seneca-mesh')

var envs = process.env
var opts = {
  seneca: {
    tag: envs.BASE_TAG || 'base'
  },
  mesh: {
    base: true,
    host: process.env.BASE_SERVICE_HOST || '127.0.0.1',
    sneeze: {
      silent: false
    }
  }
}

Seneca(opts.seneca)
  .use(Mesh, opts.mesh)

1_auth.js

'use strict'

var ENVS = process.env

var serviceHost = ENVS.POD_IP || '127.0.0.1'
var baseHost = ENVS.BASE_SERVICE_HOST || '127.0.0.1'

var opts = {
  seneca: {
    tag: 'auth'
  },
  mongo: {
    uri: ENVS.MONGO_URI,
    options: {}
  },
  mesh: {
    auto: true,
    host: serviceHost,
    bases: [baseHost],
    listen: [{
      pin: [
        'role:auth,cmd:*',
        'role:auth,do:validateToken',
        'role:user,get:user',
        'role:user,list:user',
        'role:user,cmd:update',
        'role:user,add:*',
        'role:user,delete:*',
        'role:user,edit:*'
      ], 
      host: serviceHost,
      port: ENVS.PORT || 50000 + Math.floor((10000 * Math.random()))
    }]
  }
}

var Service = require('seneca')(opts.seneca)
Service.use('entity')
Service.use('mongo-store', opts.mongo)
Service.use('../lib/auth.js')
Service.use('mesh', opts.mesh)

2_api.js

'use strict'

const PORT = process.env.PORT || 3000

let AppLoader = require('./app-loader')
let AppRouter = require('./app-router')
let AppLibrary = require('./app-library')

const Server = (cb) => {
  let Chairo = AppLoader.require('chairo')
  let Async = AppLoader.require('async')
  let Hapi = AppLoader.require('hapi')
  let Bell = AppLoader.require('bell')
  let HapiJwt = AppLoader.require('hapi-auth-jwt2')

  let AppTasks = []

  AppTasks.push((doNext) => {
    AppLibrary(AppLoader, (err, libraries) => doNext(err))
  })

  AppTasks.push((doNext) => {
    const ENVS = process.env
    const opts = {
      seneca: {
        tag: 'api'
      },
      jwt: {
        password: process.env.JWT_KEY
      }
    }

    let plugins = [
      HapiJwt,
      Bell,
      { register: Chairo, options: opts.seneca }
    ]

    let Server = new Hapi.Server()

    Server.connection({
      port: PORT
    })

    Server.register(plugins, (err) => {
      if (err) {
        return cb(err)
      }

      let Seneca = Server.seneca

      let mesh_opts = {
        auto: true,
        host: ENVS.POD_IP || '127.0.0.1',
        bases: [ENVS.BASE_SERVICE_HOST || '127.0.0.1']
      }

      Seneca.use('entity')
      Seneca.use(AppLoader.get('library.jwt-strategy'), opts.jwt)
      Seneca.use('mesh', mesh_opts)

      Seneca.ready(() => doNext(null, Server))
    })
  })


  AppTasks.push((Server, doNext) => {
    AppRouter(AppLoader, (err, routes) => {
      if (err) {
        return cb(err)
      }

      Server.route(routes)
      return doNext(err, Server)
    })
  })

  Async.waterfall(AppTasks, (err, Server) => {
    if (err) {
      return cb(err)
    }
    Server.start(function (err) {
      if (err) {
        return cb(err)
      }
      return cb(null, Server)
    })
  })
}

module.exports = Server