orchestrator 1.0.1

data/lib/orchestrator/core/mixin.rb

@@ -0,0 +1,123 @@
+module Orchestrator
+    module Core
+        SCHEDULE_ACCESS_DENIED = 'schedule unavailable in a task'.freeze
+
+        module Mixin
+
+            # Returns a wrapper around a shared instance of ::UV::Scheduler
+            # 
+            # @return [::Orchestrator::Core::ScheduleProxy]
+            def schedule
+                raise SCHEDULE_ACCESS_DENIED unless @__config__.thread.reactor_thread?
+                @__config__.get_scheduler
+            end
+
+            # Looks up a system based on its name and returns a proxy to that system via a promise
+            #
+            # @param name [String] the name of the system being accessed
+            # @return [::Libuv::Q::Promise] Returns a single promise
+            def systems(name)
+                task do
+                    @__config__.get_system(name)
+                end
+            end
+
+            # Performs a long running task on a thread pool in parallel.
+            #
+            # @param callback [Proc] the work to be processed on the thread pool
+            # @return [::Libuv::Q::Promise] Returns a single promise
+            def task(callback = nil, &block)
+                thread = @__config__.thread
+                defer = thread.defer
+                thread.schedule do
+                    defer.resolve(thread.work(callback, &block))
+                end
+                defer.promise
+            end
+
+            # Thread safe status access
+            def [](name)
+                @__config__.status[name.to_sym]
+            end
+
+            # thread safe status settings
+            def []=(status, value)
+                @__config__.trak(status.to_sym, value)
+
+                # Check level to speed processing
+                if @__config__.logger.level == 0
+                    @__config__.logger.debug "Status updated: #{status} = #{value}"
+                end
+            end
+
+            # thread safe status subscription
+            def subscribe(status, callback = nil, &block)
+                callback ||= block
+                raise 'callback required' unless callback.respond_to? :call
+
+                thread = @__config__.thread
+                defer = thread.defer
+                thread.schedule do
+                    defer.resolve(@__config__.subscribe(status, callback))
+                end
+                defer.promise
+            end
+
+            # thread safe unsubscribe
+            def unsubscribe(sub)
+                @__config__.thread.schedule do
+                    @__config__.unsubscribe(sub)
+                end
+            end
+
+            def logger
+                @__config__.logger
+            end
+
+            def setting(name)
+                set = name.to_sym
+                @__config__.setting(set)
+            end
+
+            # Updates a setting that will effect the local module only
+            #
+            # @param name [String|Symbol] the setting name
+            # @param value [String|Symbol|Numeric|Array|Hash] the setting value
+            # @return [::Libuv::Q::Promise] Promise that will resolve once the setting is persisted
+            def define_setting(name, value)
+                set = name.to_sym
+                @__config__.define_setting(set, value)
+            end
+
+            def wake_device(mac, ip = '<broadcast>')
+                @__config__.thread.schedule do
+                    @__config__.thread.wake_device(mac, ip)
+                end
+            end
+
+            # Outputs any statistics collected on the module
+            def __STATS__
+                stats = {}
+                if @__config__.respond_to? :processor
+                    stats[:queue_size] = @__config__.processor.queue.length
+                    stats[:queue_waiting] = !@__config__.processor.queue.waiting.nil?
+                    stats[:queue_pause] = @__config__.processor.queue.pause
+                    stats[:queue_state] = @__config__.processor.queue.state
+
+                    stats[:last_send] = @__config__.processor.last_sent_at
+                    stats[:last_receive] = @__config__.processor.last_receive_at
+                    if @__config__.processor.timeout
+                        stats[:timeout_created] = @__config__.processor.timeout.created
+                        stats[:timeout_triggered] = @__config__.processor.timeout.trigger_count
+                        stats[:timeout_scheduled] = @__config__.processor.timeout.next_scheduled
+                    end
+                end
+
+                stats[:time_now] = @__config__.thread.now
+                stats[:schedules] = schedule.schedules.to_a
+
+                logger.debug JSON.generate(stats)
+            end
+        end
+    end
+end

data/lib/orchestrator/core/module_manager.rb

@@ -0,0 +1,258 @@
+module Orchestrator
+    module Core
+        class ModuleManager
+            def initialize(thread, klass, settings)
+                @thread = thread        # Libuv Loop
+                @settings = settings    # Database model
+                @klass = klass
+                
+                # Bit of a hack - should make testing pretty easy though
+                @status = ::ThreadSafe::Cache.new
+                @stattrak = @thread.observer
+                @logger = ::Orchestrator::Logger.new(@thread, @settings)
+
+                @updating = Mutex.new
+            end
+
+
+            attr_reader :thread, :settings, :instance
+            attr_reader :status, :stattrak, :logger
+
+
+            # Should always be called on the module thread
+            def stop
+                return if @instance.nil?
+                begin
+                    if @instance.respond_to? :on_unload, true
+                        @instance.__send__(:on_unload)
+                    end
+                rescue => e
+                    @logger.print_error(e, 'error in module unload callback')
+                ensure
+                    # Clean up
+                    @instance = nil
+                    @scheduler.clear if @scheduler
+                    if @subsciptions
+                        unsub = @stattrak.method(:unsubscribe)
+                        @subsciptions.each &unsub
+                        @subsciptions = nil
+                    end
+                    update_running_status(false)
+                end
+            end
+
+            def start
+                return true unless @instance.nil?
+                config = self
+                @instance = @klass.new
+                @instance.instance_eval { @__config__ = config }
+                if @instance.respond_to? :on_load, true
+                    begin
+                        @instance.__send__(:on_load)
+                    rescue => e
+                        @logger.print_error(e, 'error in module load callback')
+                    end
+                end
+                update_running_status(true)
+                true # for REST API
+            rescue => e
+                @logger.print_error(e, 'module failed to start')
+                false
+            end
+
+            def reloaded(mod)
+                @thread.schedule do
+                    # pass in any updated settings
+                    @settings = mod
+
+                    if @instance.respond_to? :on_update, true
+                        begin
+                            @instance.__send__(:on_update)
+                        rescue => e
+                            @logger.print_error(e, 'error in module update callback')
+                        end
+                    end
+                end
+            end
+
+            def get_scheduler
+                @scheduler ||= ::Orchestrator::Core::ScheduleProxy.new(@thread)
+            end
+
+            # This is called from Core::Mixin on the thread pool as the DB query will be blocking
+            # NOTE:: Couchbase does support non-blocking gets although I think this is simpler
+            #
+            # @return [::Orchestrator::Core::SystemProxy]
+            # @raise [Couchbase::Error::NotFound] if unable to find the system in the DB
+            def get_system(name)
+                id = ::Orchestrator::ControlSystem.bucket.get("sysname-#{name}")
+                ::Orchestrator::Core::SystemProxy.new(@thread, id.to_sym, self)
+            end
+
+            # Called from Core::Mixin - thread safe
+            def trak(name, value)
+                if @status[name] != value
+                    @status[name] = value
+
+                    # Allows status to be updated in workers
+                    # For the most part this will run straight away
+                    @thread.schedule do
+                        @stattrak.update(@settings.id.to_sym, name, value)
+                    end
+                end
+            end
+
+            # Subscribe to status updates from status in the same module
+            # Called from Core::Mixin always on the module thread
+            def subscribe(status, callback)
+                sub = @stattrak.subscribe({
+                    on_thread: @thread,
+                    callback: callback,
+                    status: status.to_sym,
+                    mod_id: @settings.id.to_sym,
+                    mod: self
+                })
+                add_subscription sub
+                sub
+            end
+
+            # Called from Core::Mixin always on the module thread
+            def unsubscribe(sub)
+                if sub.is_a? ::Libuv::Q::Promise
+                    # Promise recursion?
+                    sub.then method(:unsubscribe)
+                else
+                    @subsciptions.delete sub
+                    @stattrak.unsubscribe(sub)
+                end
+            end
+
+            # Called from subscribe and SystemProxy.subscribe always on the module thread
+            def add_subscription(sub)
+                if sub.is_a? ::Libuv::Q::Promise
+                    # Promise recursion?
+                    sub.then method(:add_subscription)
+                else
+                    @subsciptions ||= Set.new
+                    @subsciptions.add sub
+                end
+            end
+
+            # Called from Core::Mixin on any thread
+            # For Logics: instance -> system -> zones -> dependency
+            # For Device: instance -> dependency
+            def setting(name)
+                res = @settings.settings[name]
+                if res.nil?
+                    if !@settings.control_system_id.nil?
+                        sys = System.get(@settings.control_system_id)
+                        res = sys.settings[name]
+
+                        # Check if zones have the setting
+                        if res.nil?
+                            sys.zones.each do |zone|
+                                res = zone.settings[name]
+                                return res unless res.nil?
+                            end
+
+                            # Fallback to the dependency
+                            res = @settings.dependency.settings[name]
+                        end
+                    else
+                        # Fallback to the dependency
+                        res = @settings.dependency.settings[name]
+                    end
+                end
+                res
+            end
+
+            # Called from Core::Mixin on any thread
+            #
+            # Settings updates are done on the thread pool
+            # We have to replace the structure as other threads may be
+            # reading from the old structure and the settings hash is not
+            # thread safe
+            def define_setting(name, value)
+                defer = thread.defer
+                thread.schedule do
+                    defer.resolve(thread.work(proc {
+                        mod = Orchestrator::Module.find(@settings.id)
+                        mod.settings[name] = value
+                        mod.save!
+                        mod
+                    }))
+                end
+                defer.promise.then do |db_model|
+                    @settings = db_model
+                    value # Don't leak direct access to the database model
+                end
+            end
+
+
+            # override the default inspect method
+            # This provides relevant information and won't blow the stack on an error
+            def inspect
+                "#<#{self.class}:0x#{self.__id__.to_s(16)} @thread=#{@thread.inspect} running=#{!@instance.nil?} managing=#{@klass.to_s} id=#{@settings.id}>"
+            end
+
+
+            protected
+
+
+            def update_connected_status(connected)
+                id = settings.id
+
+                # Access the database in a non-blocking fashion
+                thread.work(proc {
+                    @updating.synchronize {
+                        model = ::Orchestrator::Module.find_by_id id
+
+                        if model && model.connected != connected
+                            model.connected = connected
+                            model.save!
+                            model
+                        else
+                            nil
+                        end
+                    }
+                }).then(proc { |model|
+                    # Update the model if it was updated
+                    if model
+                        @settings = model
+                    end
+                }, proc { |e|
+                    # report any errors updating the model
+                    @logger.print_error(e, 'error updating connected state in database model')
+                })
+            end
+
+            def update_running_status(running)
+                id = settings.id
+
+                # Access the database in a non-blocking fashion
+                thread.work(proc {
+                    @updating.synchronize {
+                        model = ::Orchestrator::Module.find_by_id id
+
+                        if model && model.running != running
+                            model.running = running
+                            model.connected = false if !running
+                            model.save!
+                            model
+                        else
+                            nil
+                        end
+                    }
+                }).then(proc { |model|
+                    # Update the model if it was updated
+                    if model
+                        @settings = model
+                    end
+                }, proc { |e|
+                    # report any errors updating the model
+                    @logger.print_error(e, 'error updating running state in database model')
+                })
+            end
+        end
+    end
+end

data/lib/orchestrator/core/request_proxy.rb

@@ -0,0 +1,109 @@
+module Orchestrator
+    module Core
+        PROTECTED = ::ThreadSafe::Cache.new
+        PROTECTED[:unsubscribe] = true
+        PROTECTED[:subscribe] = true
+        PROTECTED[:schedule] = true
+        PROTECTED[:systems] = true
+        #PROTECTED[:setting] = true # settings might be useful
+        PROTECTED[:system] = true
+        PROTECTED[:logger] = true
+        PROTECTED[:task] = true
+        PROTECTED[:wake_device] = true
+
+        # Object functions
+        PROTECTED[:__send__] = true
+        PROTECTED[:public_send] = true
+        PROTECTED[:taint] = true
+        PROTECTED[:untaint] = true
+        PROTECTED[:trust] = true
+        PROTECTED[:untrust] = true
+        PROTECTED[:freeze] = true
+
+        # Callbacks
+        PROTECTED[:on_load] = true
+        PROTECTED[:on_unload] = true
+        PROTECTED[:on_update] = true
+        PROTECTED[:connected] = true
+        PROTECTED[:disconnected] = true
+        PROTECTED[:received] = true
+
+        # Device module
+        PROTECTED[:send] = true
+        PROTECTED[:defaults] = true
+        PROTECTED[:disconnect] = true
+        PROTECTED[:config] = true
+
+        # Service module
+        PROTECTED[:get] = true
+        PROTECTED[:put] = true
+        PROTECTED[:post] = true
+        PROTECTED[:delete] = true
+        PROTECTED[:request] = true
+        PROTECTED[:clear_cookies] = true
+        PROTECTED[:use_middleware] = true
+
+
+        class RequestProxy
+            def initialize(thread, mod)
+                @mod = mod
+                @thread = thread
+            end
+
+            # Simplify access to status variables as they are thread safe
+            def [](name)
+                @mod.instance[name]
+            end
+
+            def []=(status, value)
+                @mod.instance[status] = value
+            end
+
+            # Returns true if there is no object to proxy
+            #
+            # @return [true|false]
+            def nil?
+                @mod.nil?
+            end
+
+            # Returns true if the module responds to the given method
+            #
+            # @return [true|false]
+            def respond_to?(symbol, include_all = false)
+                if @mod
+                    @mod.instance.respond_to?(symbol, include_all)
+                else
+                    false
+                end
+            end
+
+            # All other method calls are wrapped in a promise
+            def method_missing(name, *args, &block)
+                defer = @thread.defer
+
+                if @mod.nil?
+                    err = Error::ModuleUnavailable.new "method '#{name}' request failed as the module is not available at this time"
+                    defer.reject(err)
+                    # TODO:: debug log here
+                elsif ::Orchestrator::Core::PROTECTED[name]
+                    err = Error::ProtectedMethod.new "attempt to access module '#{@mod.settings.id}' protected method '#{name}'"
+                    defer.reject(err)
+                    @mod.logger.warn(err.message)
+                else
+                    @mod.thread.schedule do
+                        begin
+                            defer.resolve(
+                                @mod.instance.public_send(name, *args, &block)
+                            )
+                        rescue => e
+                            @mod.logger.print_error(e)
+                            defer.reject(e)
+                        end
+                    end
+                end
+
+                defer.promise
+            end
+        end
+    end
+end