orchestrator 1.0.1

data/lib/orchestrator/core/requests_proxy.rb

@@ -0,0 +1,47 @@
+module Orchestrator
+    module Core
+        class RequestsProxy
+            def initialize(thread, modules)
+                if modules.nil?
+                    @modules = []
+                else
+                    @modules = modules.is_a?(Array) ? modules : [modules]
+                end
+                @thread = thread
+            end
+
+            # Returns true if there is no object to proxy
+            #
+            # @return [true|false]
+            def nil?
+                @modules.empty?
+            end
+            alias_method :empty?, :nil?
+
+            def method_missing(name, *args, &block)
+                if ::Orchestrator::Core::PROTECTED[name]
+                    err = Error::ProtectedMethod.new "attempt to access a protected method '#{name}' in multiple modules"
+                    ::Libuv::Q.reject(@thread, err)
+                    # TODO:: log warning err.message
+                else
+                    promises = @modules.map do |mod|
+                        defer = mod.thread.defer
+                        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
+                        defer.promise
+                    end
+
+                    @thread.finally(*promises)
+                end
+            end
+        end
+    end
+end

data/lib/orchestrator/core/schedule_proxy.rb

@@ -0,0 +1,49 @@
+require 'set'
+
+
+module Orchestrator
+    module Core
+        class ScheduleProxy
+            def initialize(thread)
+                @scheduler = thread.scheduler
+                @schedules = Set.new
+            end
+
+            attr_reader :schedules
+
+            def every(*args, &block)
+                add_schedule @scheduler.every(*args, &block)
+            end
+
+            def in(*args, &block)
+                add_schedule @scheduler.in(*args, &block)
+            end
+
+            def at(*args, &block)
+                add_schedule @scheduler.at(*args, &block)
+            end
+
+            def cron(*args, &block)
+                add_schedule @scheduler.cron(*args, &block)
+            end
+
+            def clear
+                @schedules.each do |schedule|
+                    schedule.cancel
+                end
+            end
+
+
+            protected
+
+
+            def add_schedule(schedule)
+                @schedules.add(schedule)
+                schedule.finally do
+                    @schedules.delete(schedule)
+                end
+                schedule
+            end
+        end
+    end
+end

data/lib/orchestrator/core/system_proxy.rb

@@ -0,0 +1,153 @@
+require 'set'
+
+
+module Orchestrator
+    module Core
+        class SystemProxy
+            def initialize(thread, sys_id, origin = nil)
+                @system = sys_id.to_sym
+                @thread = thread
+                @origin = origin    # This is the module that requested the proxy
+            end
+
+            # Alias for get
+            def [](mod)
+                get mod
+            end
+
+            # Provides a proxy to a module for a safe way to communicate across threads
+            #
+            # @param module [String, Symbol] the name of the module in the system
+            # @param index [Integer] the index of the desired module (starting at 1)
+            # @return [::Orchestrator::Core::RequestsProxy] proxies requests to a single module
+            def get(mod, index = 1)
+                index -= 1  # Get the real index
+                name = mod.to_sym
+
+                RequestProxy.new(@thread, system.get(name, index))
+            end
+
+            # Checks for the existence of a particular module
+            #
+            # @param module [String, Symbol] the name of the module in the system
+            # @param index [Integer] the index of the desired module (starting at 1)
+            # @return [true, false] does the module exist?
+            def exists?(mod, index = 1)
+                index -= 1  # Get the real index
+                name = mod.to_sym
+
+                !system.get(name, index).nil?
+            end
+
+            # Provides a proxy to multiple modules. A simple way to send commands to multiple devices
+            #
+            # @param module [String, Symbol] the name of the module in the system
+            # @return [::Orchestrator::Core::RequestsProxy] proxies requests to multiple modules
+            def all(mod)
+                name = mod.to_sym
+                RequestsProxy.new(@thread, system.all(name))
+            end
+
+            # Iterates over the modules in the system. Can also specify module types.
+            # 
+            # @param mod_name [String, Symbol] the optional names of modules to iterate over
+            # @yield [Module Instance, Symbol, Integer] yields the modules with their name and index
+            def each(*args)
+                mods = args.empty? ? modules : args
+                mods.each do |mod|
+                    number = count(mod)
+                    (1..number).each do |index|
+                        yield(get(mod, index), mod, index)
+                    end
+                end
+            end
+
+            # Grabs the number of a particular device type
+            #
+            # @param module [String, Symbol] the name of the module in the system
+            # @return [Integer] the number of modules with a shared name
+            def count(mod)
+                name = mod.to_sym
+                system.count(name)
+            end
+
+            # Returns a list of all the module names in the system
+            #
+            # @return [Array] a list of all the module names
+            def modules
+                system.modules
+            end
+
+            # Returns the system name as defined in the database
+            #
+            # @return [String] the name of the system 
+            def name
+                system.config.name
+            end
+
+            # Used to be notified when an update to a status value occurs
+            #
+            # @param module [String, Symbol] the name of the module in the system
+            # @param index [Integer] the index of the module as there may be more than one
+            # @param status [String, Symbol] the name of the status variable
+            # @param callback [Proc] method, block, proc or lambda to be called when a change occurs
+            # @return [Object] a reference to the subscription for un-subscribing
+            def subscribe(mod_name, index, status = nil, callback = nil, &block)
+                # Allow index to be optional
+                if not index.is_a?(Integer)
+                    callback = status || block
+                    status = index.to_sym
+                    index = 1
+                else
+                    callback ||= block
+                end
+                mod_name = mod_name.to_sym
+
+                raise 'callback required' unless callback.respond_to? :call
+
+                # We need to get the system to schedule threads
+                sys = system
+                options = {
+                    sys_id: @system,
+                    sys_name: sys.config.name,
+                    mod_name: mod_name,
+                    index: index,
+                    status: status,
+                    callback: callback,
+                    on_thread: @thread
+                }
+
+                # if the module exists, subscribe on the correct thread
+                # use a bit of promise magic as required
+                mod_man = sys.get(mod_name, index - 1)
+                sub = if mod_man
+                    defer = @thread.defer
+
+                    options[:mod_id] = mod_man.settings.id.to_sym
+                    options[:mod] = mod_man
+                    thread = mod_man.thread
+                    thread.schedule do
+                        defer.resolve (
+                            thread.observer.subscribe(options)
+                        )
+                    end
+
+                    defer.promise
+                else
+                    @thread.observer.subscribe(options)
+                end
+
+                @origin.add_subscription sub if @origin
+                sub
+            end
+
+
+            protected
+
+
+            def system
+                ::Orchestrator::System.get(@system)
+            end
+        end
+    end
+end

data/lib/orchestrator/datagram_server.rb

@@ -0,0 +1,114 @@
+
+module Orchestrator
+    class UdpService < ::UV::DatagramConnection
+        def initialize(*args)
+            super(*args)
+
+            @callbacks = {
+                # ip => port => callback
+            }
+        end
+        
+        def attach(ip, port, callback)
+            @loop.schedule do
+                ports = @callbacks[ip.to_sym] ||= {}
+                ports[port.to_i] = callback
+            end
+        end
+
+        def detach(ip_raw, port)
+            @loop.schedule do
+                ip = ip_raw.to_sym
+                ip_ports = @callbacks[ip]
+                if ip_ports
+                    ip_ports.delete(port.to_i)
+                    @callbacks.delete(ip) if ip_ports.empty?
+                end
+            end
+        end
+
+        def on_read(data, ip, port, transport)
+            ip_ports = @callbacks[ip.to_sym]
+            if ip_ports
+                callback = ip_ports[port.to_i]
+                if callback
+                    callback.call(data)
+                end
+            end
+        end
+
+        def send(ip, port, data)
+            @loop.schedule do 
+                send_datagram(data, ip, port)
+            end
+        end
+    end
+
+
+    class UdpBroadcast < ::UV::DatagramConnection
+        def post_init
+            @transport.enable_broadcast
+        end
+
+        def send(ip, port, data)
+            @loop.schedule do 
+                send_datagram(data, ip, port)
+            end
+        end
+    end
+end
+
+
+module Libuv
+    class Loop
+        def udp_service
+            if @udp_service
+                @udp_service
+            else
+                CRITICAL.synchronize {
+                    return @udp_service if @udp_service
+
+                    port = Rails.configuration.orchestrator.datagram_port || 0
+
+                    if port == 0
+                        @udp_service = ::UV.open_datagram_socket(::Orchestrator::UdpService)
+                    elsif defined? @@udp_service
+                        @udp_service = @@udp_service
+                    else # define a class variable at the specified port
+                        @udp_service = ::UV.open_datagram_socket(::Orchestrator::UdpService, '0.0.0.0', port)
+                        @@udp_service = @udp_service
+                    end
+                }
+            end
+        end
+
+        def udp_broadcast(data, port = 9, ip = '<broadcast>')
+            if @udp_broadcast
+                @udp_broadcast.send(ip, port, data)
+            else
+                CRITICAL.synchronize {
+                    return @udp_broadcast.send(ip, port, data) if @udp_broadcast
+                    
+                    port = Rails.configuration.orchestrator.broadcast_port || 0
+
+                    if port == 0
+                        @udp_broadcast = ::UV.open_datagram_socket(::Orchestrator::UdpBroadcast)
+                    elsif defined? @@udp_broadcast
+                        @udp_broadcast = @@udp_broadcast
+                    else # define a class variable at the specified port
+                        @udp_broadcast = ::UV.open_datagram_socket(::Orchestrator::UdpBroadcast, '0.0.0.0', port)
+                        @@udp_broadcast = @udp_broadcast
+                    end
+
+                    @udp_broadcast.send(ip, port, data)
+                }
+            end
+        end
+
+        def wake_device(mac, ip = '<broadcast>')
+            mac = mac.gsub(/(0x|[^0-9A-Fa-f])*/, "").scan(/.{2}/).pack("H*H*H*H*H*H*")
+            magicpacket = (0xff.chr) * 6 + mac * 16
+            udp_broadcast(magicpacket, 9, ip)
+        end
+    end
+end

data/lib/orchestrator/dependency_manager.rb

@@ -0,0 +1,131 @@
+require 'thread'    # For Mutex
+require 'set'
+
+
+module Orchestrator
+    class DependencyManager
+        include Singleton
+
+
+        def initialize
+            @load_mutex = Mutex.new
+            @dependencies = ThreadSafe::Cache.new
+            @loop = ::Libuv::Loop.default
+            @loop.next_tick do
+                @logger = ::Orchestrator::Control.instance.logger
+            end
+        end
+
+
+        def load(dependency, force = false)
+            defer = @loop.defer
+            
+            classname = dependency.class_name
+            class_lookup = classname.to_sym
+            class_object = @dependencies[class_lookup]
+
+            if class_object && force == false
+                defer.resolve(class_object)
+            else
+                # We need to ensure only one file loads at a time
+                @load_mutex.synchronize {
+                    perform_load(dependency, defer, classname, class_lookup, force)
+                }
+            end
+
+            defer.promise
+        end
+
+        def force_load(file)
+            defer = @loop.defer
+
+            if File.exists?(file)
+                begin
+                    @load_mutex.synchronize {
+                        load file
+                    }
+                    defer.resolve(file)
+                rescue Exception => e
+                    defer.reject(e)
+                    print_error(e, 'force load failed')
+                end
+            else
+                defer.reject(Error::FileNotFound.new("could not find '#{file}'"))
+            end
+
+            defer.promise
+        end
+
+
+        protected
+
+
+        # Always called from within a Mutex
+        def perform_load(dependency, defer, classname, class_lookup, force)
+            if force == false
+                class_object = @dependencies[class_lookup]
+                if class_object
+                    defer.resolve(class_object)
+                    return
+                end
+            end
+
+            begin
+                file = "#{classname.underscore}.rb"
+                class_object = nil
+
+                ::Rails.configuration.orchestrator.module_paths.each do |path|
+                    if ::File.exists?("#{path}/#{file}")
+
+                        ::Kernel.load "#{path}/#{file}"
+                        class_object = classname.constantize
+
+                        case dependency.role
+                        when :device
+                            include_device(class_object)
+                        when :service
+                            include_service(class_object)
+                        else
+                            include_logic(class_object)
+                        end
+
+                        @dependencies[class_lookup] = class_object
+                        defer.resolve(class_object)
+                        break
+                    end
+                end
+                
+                if class_object.nil?
+                    defer.reject(Error::FileNotFound.new("could not find '#{file}'"))
+                end
+            rescue Exception => e
+                defer.reject(e)
+                print_error(e, 'error loading dependency')
+            end
+        end
+
+        def include_logic(klass)
+            klass.class_eval do
+                include ::Orchestrator::Logic::Mixin
+            end
+        end
+
+        def include_device(klass)
+            klass.class_eval do
+                include ::Orchestrator::Device::Mixin
+            end
+        end
+
+        def include_service(klass)
+            klass.class_eval do
+                include ::Orchestrator::Service::Mixin
+            end
+        end
+
+        def print_error(e, msg = '')
+            msg << "\n#{e.message}"
+            msg << "\n#{e.backtrace.join("\n")}" if e.respond_to? :backtrace
+            @logger.error(msg)
+        end
+    end
+end