fancybox2 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 36eebce6aa26f750e0d2974e2f7ea1a2f029174bddb6d3bb6b8a4adb4e01fd4a
+  data.tar.gz: 7f0d67c72d4472d950bbb581a2b2829cea9a0527bdc4377568a3d4293039ccbc
+SHA512:
+  metadata.gz: 38a9da60393ba4308c46fca05ef6764111a872128f89cfc62bda02a998df36f64a08f41ef86eedc4108011368cd1eeaf682bbdda1f299ce16bfe2d66dfc075eb
+  data.tar.gz: 6600b35da0bf560f6b6f84edaa7f2307b6a49c4ae8e0c831cda9f764e0652b8f25384df236b87f096e19faba44ee86653381decef46c22d00597f65dfc807ea5

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Fancy Pixel S.r.l. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+<p align="center">
+  <img width="480" src="assets/logo.png"/>
+</p>
+
+[![Build Status](https://travis-ci.org/space-bunny/ruby_sdk.svg)](https://travis-ci.org/space-bunny/ruby_sdk)
+[![Gem Version](https://badge.fury.io/rb/spacebunny.svg)](https://badge.fury.io/rb/spacebunny)
+
+[SpaceBunny](http://spacebunny.io) is the IoT platform that makes it easy for you and your devices to send and
+exchange messages with a server or even with each other. You can store the data, receive timely event notifications,
+monitor live streams and remotely control your devices. Easy to use, and ready to scale at any time.
+
+This is the source code repository for Ruby SDK.
+Please feel free to contribute!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'spacebunny'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spacebunny
+
+After you have signed up for a [SpaceBunny](http://spacebunny.io)'s account, follow the
+[Getting Started](http://getting_started_link) guide for a one minute introduction to the platform concepts
+and a super rapid setup.
+
+This SDK provides Device and LiveStream clients and currently supports the AMQP protocol.
+
+## Device - Basic usage
+
+Pick a device, view its configurations and copy the Device Key. Instantiate a new `Spacebunny::Device` client,
+providing the Device Key:
+
+```ruby
+dev = Spacebunny::Device.new 'device_key'
+```
+
+the SDK will auto-configure, contacting [SpaceBunny APIs](http://doc.spacebunny.io/api) endpoint, retrieving the
+connection configurations and required parameters. Nothing remains but to connect:
+
+```ruby
+dev.connect
+```
+
+### Publish
+
+Ok, all set up! Let's publish some message:
+
+```ruby
+# We're assuming you have created a 'data' channel and you have enabled it for your device
+
+# Let's publish, for instance, some JSON. Payload can be everything you want,
+# SpaceBunny does not impose any constraint on format or content.
+
+require 'json'  # to convert our payload to JSON
+
+# Publish one message every second for a minute.
+60.times do
+  # Generate some random data
+  payload = { greetings: 'Hello, World!', temp: rand(20.0..25.0), foo: rand(100..200) }.to_json
+    
+  # Publish
+  dev.publish :data, payload
+  
+  # Give feedback on what has been published
+  puts "Published: #{payload}"
+
+  # Take a nap...
+  sleep 1
+end
+```
+
+Let's check out that our data is really being sent by going to our web dashboard: navigate to devices, select the
+device and click on 'LIVE DATA'. Select the 'data' channel from the dropdown and click **Start**.
+Having published data as JSON allows SpaceBunny's web UI to parse them and visualize a nice
+realtime graph: On the **Chart** tab write `temp` in the input field and press enter.
+You'll see the graph of the `temp` parameter being rendered. If you want to plot more parameters,
+just use a comma as separator e.g: temp, pressure, voltage
+On the **Messages** tab you'll see raw messages' payloads received on this channel.
+
+### Inbox
+
+Waiting for and reading messages from the device's Inbox is trivial:
+
+```ruby
+dev.inbox(wait: true, ack: :auto) do |message|
+  puts "Received: #{message.payload}"
+end
+```
+
+`wait` option (default false) causes the script to wait forever on the receive block
+
+`ack` option can have two values: `:manual` (default) or `:auto`. When `:manual` you are responsible to ack the messages,
+for instance:
+
+```ruby
+dev.inbox(wait: true, ack: :manual) do |message|
+  puts "Received: #{message.payload}"
+  # Manually ack the message
+  message.ack
+end
+```
+This permits to handle errors or other critical situations
+
+## Live Stream - Basic usage
+
+For accessing a Live Stream a Live Stream Key's is required. On SpaceBunny's Web UI, go to the Streams section,
+click on "Live Stream Keys" and pick or create one.
+
+```ruby
+live = Spacebunny::LiveStream.new client: 'live_stream_key_client', secret: 'live_stream_key_secret'
+```
+
+Similarly to the Device client, the SDK will auto-configure itself, contacting [SpaceBunny APIs](http://doc.spacebunny.io/api)
+endpoint, retrieving the connection configurations and required parameters. Nothing remains but to connect:
+
+```ruby
+live.connect
+```
+
+### Reading live messages
+
+Each LiveStream has its own cache that will keep always last 100 messages (FIFO, when there are more than 100 messages,
+the oldest ones get discarded). If you want to consume messages in a parallel way, you shoul use the cache and connect
+ as many LiveStream clients as you need: this way messages will be equally distributed to clients.
+
+```ruby
+live.message_from_cache :some_live_stream, wait: true, ack: :auto do |message|
+  puts "Received from cache: #{message.payload}"
+end
+
+# An equivalent method is:
+# live.message_from :some_live_stream, from_cache: true, wait: true, ack: :auto do |message|
+#   puts "Received from cache: #{message.payload}"
+# end
+```
+
+Conversely, if you want that each client will receive a copy of each message, don't use the cache:
+
+```ruby
+live.message_from :some_live_stream, wait: true, ack: :auto do |message|
+  puts "Received a copy of: #{message.payload}"
+end
+```
+
+Every client subscribed to the LiveStream in this way will receive a copy of the message.
+
+## TLS
+
+Instantiating a TLS-secured connection is trivial:
+
+```ruby
+# For a Device
+
+dev = Spacebunny::Device.new key, tls: true
+
+# Similarly, for a Live Stream
+
+live = Spacebunny::LiveStream.new client, secret, tls: true
+```
+
+## More examples and options
+
+Take a look at the ```examples``` directory for more code samples and further details about available options.
+
+
+### Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/FancyPixel/spacebunny_ruby.
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere
+to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+### Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/fancybox2.rb

@@ -0,0 +1,15 @@
+require 'zeitwerk'
+require 'logger'
+
+loader = Zeitwerk::Loader.for_gem
+core_ext = "#{__dir__}/fancybox2/core_ext/"
+loader.ignore core_ext
+loader.inflector.inflect 'mqtt_log_device' => 'MQTTLogDevice',
+                         'json_formatter' => 'JSONFormatter'
+loader.setup
+
+require "#{core_ext}/hash"
+require "#{core_ext}/array"
+
+module Fancybox2
+end

data/lib/fancybox2/core_ext/array.rb

@@ -0,0 +1,18 @@
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
+  def extract_options
+    if last.is_a?(Hash)
+      pop
+    else
+      {}
+    end
+  end
+end

data/lib/fancybox2/core_ext/hash.rb

@@ -0,0 +1,170 @@
+# :nocov:
+class Hash
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    return enum_for(:transform_keys!) unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys { |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys! { |key| key.to_s }
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end
+
+  alias_method :to_options, :symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys! { |key| key.to_sym rescue key }
+  end
+
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising
+  # ArgumentError on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      unless valid_keys.include?(k)
+        raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+      end
+    end
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys { |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys!
+    deep_transform_keys! { |key| key.to_s }
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys! { |key| key.to_sym rescue key }
+  end
+
+  private
+
+  # support methods for deep transforming nested hashes and arrays
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| _deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/fancybox2/logger/json_formatter.rb

@@ -0,0 +1,19 @@
+require 'logger'
+require 'json'
+
+module Fancybox2
+  module Logger
+    class JSONFormatter < ::Logger::Formatter
+      def call(severity, time, progname, msg)
+        json = JSON.generate(
+            level: severity,
+            timestamp: time.utc.strftime('%Y-%m-%dT%H:%M:%S.%3NZ'.freeze),
+            #progname: progname,
+            message: msg,
+            pid: Process.pid
+        )
+        "#{json}\n"
+      end
+    end
+  end
+end

data/lib/fancybox2/logger/mqtt_log_device.rb

@@ -0,0 +1,28 @@
+module Fancybox2
+  module Logger
+    class MQTTLogDevice
+
+      attr_accessor :client, :topic
+
+      def initialize(topic, *args)
+        @topic = topic
+        options = args.extract_options.deep_symbolize_keys
+        @client = options[:client]
+        unless @client.respond_to?(:publish)
+          raise ArgumentError, "provided client does not respond to 'publish'"
+        end
+      end
+
+      def write(message)
+        if @client.connected?
+          @client.publish @topic, message
+        end
+      end
+
+      def close(*args)
+        # Do nothing.
+        # Future: close only if client is internal
+      end
+    end
+  end
+end

data/lib/fancybox2/logger/multi.rb

@@ -0,0 +1,127 @@
+module Fancybox2
+  module Logger
+
+    # Log on multiple loggers at the same time
+    #
+    # Usage example:
+    #
+    # file_logger = Logger.new(File.open("log/debug.log", "a"))
+    # stdout_logger = Logger.new(STDOUT)
+    # Create a logger that logs both to STDOUT and log_file at the same time with 'info' loglevel
+    # multi_logger = Fancybox2::Logger::Multi.new(file_logger, stdout_logger, level: :info))
+
+    class Multi
+      attr_accessor :loggers, :level, :escape_data, :progname
+
+      # logger_1, logger_2, ... , level: nil, loggers: nil, escape_data: true)
+      def initialize(*args)
+        options = args.extract_options.deep_symbolize_keys
+        loggers = args
+        if !loggers.is_a?(Array) || loggers.size.zero?
+          raise ArgumentError.new("provide at least one logger instance")
+        end
+
+        @level = normalize_log_level(options[:level])
+        @escape_data = options[:escape_data] || false
+        @progname = options[:progname]
+
+        self.loggers = loggers
+        # Set properties
+        # Override Loggers levels only if explicitly required
+        self.level = @level if options[:level] # Do not use @level because it has already been processed
+        # Override Logger's Formatter only if explicitly required
+        self.escape_data = @escape_data if @escape_data
+        self.progname = @progname if @progname
+
+        define_methods
+      end
+
+      def add(level, *args)
+        @loggers.each { |logger| logger.add(level, *args) }
+      end
+      alias log add
+
+      def add_logger(logger)
+        @loggers << logger
+      end
+
+      def close
+        @loggers.map(&:close)
+      end
+
+      def default_log_level
+        'info'
+      end
+
+      def escape_data=(value)
+        if value
+          @loggers.each do |logger|
+            escape_data_of logger
+          end
+        else
+          @loggers.each { |logger| logger.formatter = ::Logger::Formatter.new }
+        end
+      end
+
+      def level=(level)
+        @level = normalize_log_level(level)
+        @loggers.each { |logger| logger.level = level }
+      end
+
+      def loggers=(new_loggers)
+        @loggers = []
+        new_loggers.each do |logger|
+          # Check if provided loggers are real Loggers
+          unless logger.is_a? ::Logger
+            raise ArgumentError.new("one of the provided loggers is not of class Logger, but of class '#{logger.class}'")
+          end
+          # Add Logger to the list
+          add_logger logger
+        end
+      end
+
+      def progname=(name)
+        loggers.each do |logger|
+          logger.progname = name
+        end
+      end
+
+      private
+
+      def define_methods
+        ::Logger::Severity.constants.each do |level|
+          define_singleton_method(level.downcase) do |args|
+            @loggers.each { |logger| logger.add(normalize_log_level(level.downcase), *args) }
+          end
+
+          define_singleton_method("#{ level.downcase }?".to_sym) do
+            @level <= ::Logger::Severity.const_get(level)
+          end
+        end
+      end
+
+      def escape_data_of(logger)
+        original_formatter = ::Logger::Formatter.new
+        logger.formatter = proc do |severity, datetime, progname, msg|
+          original_formatter.call(severity, datetime, progname, msg.dump)
+        end
+      end
+
+      ##
+      # @param [String] log_level
+      def normalize_log_level(log_level)
+        case log_level
+        when :unknown, ::Logger::UNKNOWN, 'unknown' then ::Logger::UNKNOWN
+        when :debug,   ::Logger::DEBUG,   'debug'   then ::Logger::DEBUG
+        when :info,    ::Logger::INFO,    'info'    then ::Logger::INFO
+        when :warn,    ::Logger::WARN,    'warn'    then ::Logger::WARN
+        when :error,   ::Logger::ERROR,   'error'   then ::Logger::ERROR
+        when :fatal,   ::Logger::FATAL,   'fatal'   then ::Logger::FATAL
+        else
+          # puts "Fancybox2::Logger::Multi#normalize_log_level, log_level value '#{log_level.inspect}' not supported, defaulting to '#{default_log_level}'"
+          normalize_log_level(default_log_level)
+        end
+      end
+    end
+  end
+end

data/lib/fancybox2/module/base.rb

@@ -0,0 +1,426 @@
+require 'json'
+require 'yaml'
+require 'logger'
+require 'paho-mqtt'
+require 'concurrent-ruby'
+
+module Fancybox2
+  module Module
+    class Base
+
+      attr_reader :logger, :mqtt_client, :fbxfile, :fbxfile_path, :status
+      attr_accessor :configs
+
+      def initialize(fbxfile_path, options = {})
+        unless fbxfile_path || fbxfile_path.is_a?(String) || fbxfile_path.empty?
+          raise FbxfileNotProvided
+        end
+
+        @fbxfile_path = fbxfile_path
+        options.deep_symbolize_keys!
+        @internal_mqtt_client = false
+
+        @fbxfile = check_and_return_fbxfile options.fetch(:fbxfile, load_fbx_file)
+        @mqtt_client_params = options[:mqtt_client_params] || {}
+        check_or_build_mqtt_client options[:mqtt_client]
+        @log_level = options.fetch :log_level, ::Logger::INFO
+        @log_progname = options.fetch :log_progname, 'Fancybox2::Module::Base'
+        @logger = options.fetch :logger, create_default_logger
+        @status = :stopped
+        @alive_task = nil
+      end
+
+      def alive_message_data(&block)
+        if block_given?
+          @alive_message_data = block
+          return
+        end
+        @alive_message_data.call if @alive_message_data
+      end
+
+      def alive_message_data=(callback)
+        @alive_message_data = callback if callback.is_a?(Proc)
+      end
+
+      def message_to(dest, action = '', payload = '', retain = false, qos = 2)
+        if mqtt_client.connected?
+          topic = topic_for dest: dest, action: action
+          payload = case payload
+                    when Hash, Array
+                      payload.to_json
+                    else
+                      payload
+                    end
+          logger.debug "#{self.class}#message_to '#{topic}' payload: #{payload}"
+          mqtt_client.publish topic, payload, retain, qos
+        else
+          logger.error 'MQTT client not connected to broker'
+        end
+      end
+
+      def name
+        fbxfile[:name]
+      end
+
+      def on_action(action, callback = nil, &block)
+        topic = topic_for source: :core, action: action
+        mqtt_client.add_topic_callback topic do |packet|
+          # :nocov:
+          payload = packet.payload
+          # Try to parse payload as JSON. Rescue with original payload in case of error
+          packet.payload = JSON.parse(payload) rescue payload
+          if block_given?
+            block.call packet
+          elsif callback && callback.is_a?(Proc)
+            callback.call packet
+          end
+          # :nocov:
+        end
+      end
+
+      def on_configs(packet = nil, &block)
+        logger.debug 'on_configs'
+        if block_given?
+          @on_configs = block
+          return
+        end
+        @configs = begin
+                     # Try to parse
+                     JSON.parse packet.payload
+                   rescue JSON::ParserError
+                     logger.debug 'on_configs: failed parsing packet as JSON, retrying with YAML'
+                     begin
+                       # Try to parse YAML
+                       YAML.load packet.payload
+                     rescue StandardError
+                       logger.debug 'on_configs: failed parsing packet as YAML. Falling back to raw payload'
+                       # Fallback to original content
+                       packet.payload
+                     end
+                   end
+        @on_configs.call(packet) if @on_configs
+      end
+
+      def on_configs=(callback)
+        @on_configs = callback if callback.is_a?(Proc)
+      end
+
+      def on_logger(packet = nil, &block)
+        if block_given?
+          @on_logger = block
+          return
+        end
+        @on_logger.call(packet) if @on_logger
+        logger_configs = packet.payload
+        logger.level = logger_configs['level'] if logger_configs['level']
+      end
+
+      def on_logger=(callback)
+        @on_logger = callback if callback.is_a?(Proc)
+      end
+
+      def on_restart(packet = nil, &block)
+        if block_given?
+          @on_restart = block
+          return
+        end
+        @on_restart.call(packet) if @on_restart
+        # Stop + start
+        on_stop
+        on_start packet
+      end
+
+      def on_restart=(callback)
+        @on_restart = callback if callback.is_a?(Proc)
+      end
+
+      def on_shutdown(do_exit = true, &block)
+        if block_given?
+          @on_shutdown = block
+          return
+        end
+
+        shutdown_ok = true
+        logger.debug "Received 'shutdown' command"
+        # Stop sending alive messages
+        @alive_task.shutdown if @alive_task
+
+        begin
+          # Call user code if any
+          @on_shutdown.call if @on_shutdown
+        rescue StandardError => e
+          logger.error "Error during shutdown: #{e.message}"
+          shutdown_ok = false
+        end
+
+        # Signal core that we've executed shutdown operations.
+        # This message is not mandatory, so keep it simple
+        shutdown_message = shutdown_ok ? 'ok' : 'nok'
+        logger.debug "Sending shutdown message to core with status '#{shutdown_message}'"
+        message_to :core, :shutdown, { status: shutdown_message }
+        sleep 0.05 # Wait some time in order to be sure that the message has been published (message is not mandatory)
+
+        if mqtt_client && mqtt_client.connected?
+          # Gracefully disconnect from broker and exit
+          logger.debug 'Disconnecting from broker'
+          mqtt_client.disconnect
+        end
+
+        if do_exit
+          # Exit from process
+          status_code = shutdown_ok ? 0 : 1
+          logger.debug "Exiting with status code #{status_code}"
+          exit status_code
+        end
+      end
+
+      def on_shutdown=(callback)
+        @on_shutdown = callback if callback.is_a?(Proc)
+      end
+
+      def on_start(packet = nil, &block)
+        if block_given?
+          @on_start = block
+          return
+        end
+        # Call user code
+        @on_start.call(packet) if @on_start
+
+        configs = packet ? packet.payload : {}
+        interval = configs['aliveTimeout'] || 1000
+        # Start code execution from scratch
+        logger.debug "Received 'start'"
+        @status = :running
+        start_sending_alive interval: interval
+      end
+
+      def on_start=(callback)
+        @on_start = callback if callback.is_a?(Proc)
+      end
+
+      def on_stop(&block)
+        if block_given?
+          @on_stop = block
+          return
+        end
+        @on_stop.call if @on_stop
+        @status = :stopped
+        # Stop code execution, but keep broker connection and continue to send alive
+      end
+
+      def on_stop=(callback)
+        @on_stop = callback if callback.is_a?(Proc)
+      end
+
+      def remove_action(action)
+        topic = topic_for source: :core, action: action
+        mqtt_client.remove_topic_callback topic
+      end
+
+      def shutdown(do_exit = true)
+        on_shutdown do_exit
+      end
+
+      def start
+        on_start
+      end
+
+      def start_sending_alive(interval: 5000)
+        # TODO: replace the alive interval task with Eventmachine?
+        # Interval is expected to be msec, so convert it to secs
+        interval /= 1000
+        @alive_task.shutdown if @alive_task
+        @alive_task = Concurrent::TimerTask.new(execution_interval: interval, timeout_interval: 2, run_now: true) do
+          packet = { status: @status, lastSeen: Time.now.utc }
+          if @alive_message_data
+            packet[:data] = @alive_message_data.call
+          end
+          message_to :core, :alive, packet
+        end
+        @alive_task.execute
+      end
+
+      def running?
+        @status.eql? :running
+      end
+
+      def stopped?
+        @status.eql? :stopped
+      end
+
+      def setup(retry_connection = true)
+        unless @setted_up
+          begin
+            logger.debug 'Connecting to the broker...'
+            mqtt_client.connect
+          rescue PahoMqtt::Exception => e
+            # :nocov:
+            logger.error "Error while connecting to the broker: #{e.message}"
+            retry if retry_connection
+            # :nocov:
+          end
+
+          @setted_up = true
+        end
+      end
+
+      def topic_for(source: self.name, dest: self.name, action: nil, packet_type: :msg)
+        source = source.to_s
+        packet_type = packet_type.to_s
+        dest = dest.to_s
+        action = action.to_s
+
+        Config::DEFAULT_TOPIC_FORMAT % [source, packet_type, dest, action]
+      end
+
+      ## MQTT Client callbacks
+
+      def on_client_connack
+        logger.debug 'Connected to the broker'
+        # Setup default callbacks
+        default_actions.each do |action_name, callback|
+          action_name = action_name.to_s
+
+          on_action action_name do |packet|
+            # :nocov:
+            if callback.is_a? Proc
+              callback.call packet
+            else
+              logger.warn "No valid callback defined for '#{action_name}'"
+            end
+            # :nocov:
+          end
+        end
+
+        if mqtt_client.subscribed_topics.size.zero?
+          # Subscribe to all messages directed to me
+          logger.debug 'Making broker subscriptions'
+          mqtt_client.subscribe [topic_for(source: '+', action: '+'), 2]
+        end
+      end
+
+      # @note Call super if you override this method
+      def on_client_suback
+        # Client subscribed, we're ready to rock -> Tell core
+        logger.debug 'Subscriptions done'
+        logger.debug "Sending 'ready' to core"
+        message_to :core, :ready
+      end
+
+      # @note Call super if you override this method
+      def on_client_unsuback
+      end
+
+      # @note Call super if you override this method
+      def on_client_puback(message)
+      end
+
+      # @note Call super if you override this method
+      def on_client_pubrel(message)
+      end
+
+      # @note Call super if you override this method
+      def on_client_pubrec(message)
+      end
+
+      # @note Call super if you override this method
+      def on_client_pubcomp(message)
+      end
+
+      # @note Call super if you override this method
+      def on_client_message(message)
+      end
+
+      private
+
+      def check_or_build_mqtt_client(mqtt_client = nil)
+        if mqtt_client
+          unless mqtt_client.is_a? PahoMqtt::Client
+            raise Exceptions::NotValidMQTTClient.new
+          end
+          @internal_mqtt_client = false
+          @mqtt_client = mqtt_client
+        else
+          @internal_mqtt_client = true
+          @mqtt_client = PahoMqtt::Client.new mqtt_params
+        end
+      end
+
+      def check_and_return_fbxfile(hash_attributes)
+        raise ArgumentError, 'You must provide an Hash as argument' unless hash_attributes.is_a?(Hash)
+        hash_attributes.deep_symbolize_keys
+      end
+
+      def create_default_logger
+        stdout_logger = ::Logger.new STDOUT
+        broker_logger = ::Logger.new(Logger::MQTTLogDevice.new(topic_for(dest: :core, action: :logs),
+                                                               client: mqtt_client),
+                                     formatter: Logger::JSONFormatter.new)
+        logger = Logger::Multi.new stdout_logger, broker_logger,
+                                    level: @log_level,
+                                    progname: @log_progname
+        logger
+      end
+
+      # :nocov:
+      def default_actions
+        {
+            start:    proc { |packet| on_start packet },
+            stop:     proc { on_stop },
+            restart:  proc { |packet| on_restart packet },
+            shutdown: proc { on_shutdown },
+            logger:   proc { |packet| on_logger packet },
+            configs:  proc { |packet| on_configs packet }
+        }
+      end
+      # :nocov:
+
+      def load_fbx_file
+        if File.exists? @fbxfile_path
+          @fbxfile = YAML.load(File.read(@fbxfile_path)).deep_symbolize_keys
+        else
+          raise Exceptions::FbxfileNotFound.new @fbxfile_path
+        end
+      end
+
+      # :nocov:
+      def mqtt_default_params
+        {
+            host:             'localhost',
+            port:             1883,
+            mqtt_version:     '3.1.1',
+            clean_session:    true,
+            persistent:       true,
+            blocking:         false,
+            reconnect_limit:  -1,
+            reconnect_delay:  1,
+            client_id:        nil,
+            username:         nil,
+            password:         nil,
+            ssl:              false,
+            will_topic:       nil,
+            will_payload:     nil,
+            will_qos:         0,
+            will_retain:      false,
+            keep_alive:       7,
+            ack_timeout:      5,
+            on_connack:       proc { on_client_connack },
+            on_suback:        proc { on_client_suback },
+            on_unsuback:      proc { on_client_unsuback },
+            on_puback:        proc { |msg| on_client_puback msg },
+            on_pubrel:        proc { |msg| on_client_pubrel msg },
+            on_pubrec:        proc { |msg| on_client_pubrec msg },
+            on_pubcomp:       proc { |msg| on_client_pubcomp msg },
+            on_message:       proc { |msg| on_client_message msg }
+        }
+      end
+      # :nocov:
+
+      def mqtt_params
+        return @mqtt_params if @mqtt_params
+        @mqtt_params = mqtt_default_params.merge(@mqtt_client_params) { |key, old_val, new_val| new_val.nil? ? old_val : new_val }
+        @mqtt_params
+      end
+    end
+  end
+end

data/lib/fancybox2/module/config.rb

@@ -0,0 +1,7 @@
+module Fancybox2
+  module Module
+    class Config
+      DEFAULT_TOPIC_FORMAT = '%s/%s/%s/%s'
+    end
+  end
+end

data/lib/fancybox2/module/exceptions.rb

@@ -0,0 +1,27 @@
+module Fancybox2
+  module Module
+    module Exceptions
+
+      class FbxfileNotProvided < StandardError
+        def initialize(file_path, message = nil)
+          message = message || "Fbxfile.example path not provided. Given: #{file_path}"
+          super(message)
+        end
+      end
+
+      class FbxfileNotFound < StandardError
+        def initialize(file_path, message = nil)
+          message = message || "Fbxfile.example not found at #{file_path}"
+          super(message)
+        end
+      end
+
+      class NotValidMQTTClient < StandardError
+        def initialize(message = nil)
+          message = message || 'The provided MQTT client is not an instance of PahoMqtt::Client'
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/fancybox2/utils/os.rb

@@ -0,0 +1,38 @@
+module Fancybox2
+  module Utils
+    module Os
+      extend self
+
+      def identifier
+        return @indentifier if @indentifier
+
+        host_os = RbConfig::CONFIG['host_os']
+        case host_os
+        when /aix(.+)$/
+          'aix'
+        when /darwin(.+)$/
+          'darwin'
+        when /linux/
+          'linux'
+        when /freebsd(.+)$/
+          'freebsd'
+        when /openbsd(.+)$/
+          'openbsd'
+        when /netbsd(.*)$/
+          'netbsd'
+        when /dragonfly(.*)$/
+          'dragonflybsd'
+        when /solaris2/
+          'solaris2'
+        when /mswin|mingw32|windows/
+          # No Windows platform exists that was not based on the Windows_NT kernel,
+          # so 'windows' refers to all platforms built upon the Windows_NT kernel and
+          # have access to win32 or win64 subsystems.
+          'windows'
+        else
+          host_os
+        end
+      end
+    end
+  end
+end

data/lib/fancybox2/version.rb

@@ -0,0 +1,3 @@
+module Fancybox2
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: fancybox2
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alessandro Verlato
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+description:
+email: alessandro@fancypixel.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/fancybox2.rb
+- lib/fancybox2/core_ext/array.rb
+- lib/fancybox2/core_ext/hash.rb
+- lib/fancybox2/logger/json_formatter.rb
+- lib/fancybox2/logger/mqtt_log_device.rb
+- lib/fancybox2/logger/multi.rb
+- lib/fancybox2/module/base.rb
+- lib/fancybox2/module/config.rb
+- lib/fancybox2/module/exceptions.rb
+- lib/fancybox2/utils/os.rb
+- lib/fancybox2/version.rb
+homepage: https://github.com/Fancybox2/ruby-sdk
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Fancybox 2 Ruby SDK
+test_files: []