sugo-module-base

Base module for SUGOS

Table of Contents

• Requirements
• Installation
• Usage
• Advanced Usage
  • Description with $spec
  • Define Custom Class
  • Use Mixins
  • Modularize Existing Class
• License
• Links

Requirements

• Node.js ( >=6 )
• npm ( >=4 )

Installation

$ npm install sugo-module-base --save

Usage

Register a module to actor.

#!/usr/bin/env node
 
/**
 * Example usage of the caller
 */
'use strict'
 
const { Module } = require('sugo-module-base')
const sugoActor = require('sugo-actor')
const co = require('co')
 
co(function * () {
  let actor = sugoActor('http://my-sugo-cloud.example.com/actors', {
    key: 'my-actor-01',
    modules: {
      // Register the module
      module01: new Module({
        ping () { /* ... */ }
      }),
      module02: new (require('./example-custom-class'))({}),
      module03: new (require('./example-mixed-class'))({})
    }
  })
  yield actor.connect()
}).catch((err) => console.error(err))
 

Then, call the module from a remote caller.

#!/usr/bin/env node
 
/**
 * Example control from a remote caller
 * @see https://github.com/realglobe-Inc/sugo-caller
 */
'use strict'
 
const co = require('co')
const assert = require('assert')
const sugoCaller = require('sugo-caller')
 
co(function * () {
  let caller = sugoCaller('http://my-sugo-cloud.example.com/callers', {})
  let actor = caller.connect('my-actor-01')
 
  // Access to the module
  let module01 = actor.get('module01')
 
  // Send ping
  let pong = yield module01.ping()
  assert.ok(pong)
}).catch((err) => console.error(err))
 

Advanced Usage

Description with $spec

You can describe a module with $spec property. The spec object must conform to module_spec.json, a JSON-Schema.

#!/usr/bin/env node
 
/**
 * Example usage of the caller
 */
'use strict'
 
const { Module } = require('sugo-module-base')
const sugoActor = require('sugo-actor')
const co = require('co')
 
co(function * () {
  let actor = sugoActor('http://my-sugo-cloud.example.com/actors', {
    key: 'my-actor-01',
    modules: {
      // Register the module
      module01: new Module({
        ping () { /* ... */ },
        get $spec () {
          /**
           * Module specification.
           * @see https://github.com/realglobe-Inc/sg-schemas/blob/master/lib/module_spec.json
           */
          return {
            name: 'sugo-module-base-sample',
            version: '1.0.0',
            desc: 'A sample module',
            methods: {
              ping: {
                desc: 'Test the reachability of the module',
                params: []
              }
            }
          }
        }
      })
    }
  })
  yield actor.connect()
}).catch((err) => console.error(err))
 

Define Custom Class

You can define you own class by extending Module class

/**
 * @MyCustomClass
 */
'use strict'
 
const { Module } = require('sugo-module-base')
 
class MyCustomClass extends Module {
  constructor (config) {
    super(config)
  }
 
  myMethod01 () {
    /* ... */
  }
 
  get $spec () {
    return { /* ... */ }
  }
}
 
module.exports = MyCustomClass
 

Use Mixins

Sometimes you need to share functions between classes.

Javascript Class Mix-In would do this.

/**
 * Example to use mixin
 */
'use strict'
 
const { Module } = require('sugo-module-base')
 
const HiPeople = (baseClass = Module) => class extends baseClass {
  sayHi () { console.log('Hi!') }
}
 
const YoPeople = (baseClass = Module) => class extends baseClass {
  sayYo () { console.log('Yo!') }
}
 
class MyPerson extends HiPeople(YoPeople(Module)) {
  sayHiAndYo () {
    const s = this
    s.sayHi()
    s.sayYo()
  }
}
 
 
module.exports = MyPerson
 

Modularize Existing Class

Want to use an existing class? You can use modularize() method to define a new module class from existing class. Since SUGO-Actor not supports callback base function, you may need some hack.

/**
 * Example to modularize an existing class
 */
'use strict'
 
const { modularize } = require('sugo-module-base')
const sugoActor = require('sugo-actor')
const co = require('co')
 
co(function * () {
  // Existing class to modularize
  class YoPerson {
    sayYo () {
      return [ 'yo', ...arguments ].join(' ')
    }
 
    sayYoCallback (callback) {
      callback(null, this.sayYo())
    }
  }
 
  // Since you cannot load callback base module into SUGO-Actor,
  // You need wrapper class to add async method
  class YoPersonAsyncWrap extends YoPerson {
    sayYoAsync () {
      const s = this
      return new Promise((resolve, reject) => {
        this.sayYoCallback((err) =>
          err ? reject(err) : resolve()
        )
      })
    }
  }
 
  let YoModuleClass = modularize(YoPersonAsyncWrap, {
    filter (name, method) {
      let methodsToReject = [ 'sayYoCallback' ] // Strip off the callback method
      return !~methodsToReject.indexOf(name)
    }
  })
 
  // Apply the modularized class instance into actor
  let actor = sugoActor('http://my-sugo-cloud.example.com/actors', {
    key: 'my-actor-01',
    modules: {
      yo: new YoModuleClass()
    }
  })
  yield actor.connect()
})
 
 
 
 
 
 

License

This software is released under the Apache-2.0 License.

Links

• SUGOS
• Realglobe, Inc.