orchestrator 1.0.1

data/lib/orchestrator/system.rb

@@ -0,0 +1,108 @@
+require 'thread'
+
+
+module Orchestrator
+    class System
+        @@systems = ThreadSafe::Cache.new
+        @@critical = Mutex.new
+
+        def self.get(id)
+            name = id.to_sym
+            system = @@systems[name]
+            if system.nil?
+                system = self.load(name)
+            end
+            return system
+        end
+
+        def self.expire(id)
+            @@systems.delete(id.to_sym)
+        end
+
+        def self.clear_cache
+            @@critical.synchronize {
+                @@systems = ThreadSafe::Cache.new
+            }
+        end
+
+
+        attr_reader :zones, :config
+
+
+        def initialize(control_system)
+            @config = control_system
+            @controller = ::Orchestrator::Control.instance
+
+            @modules = {}
+            @config.modules.each &method(:index_module)
+
+            # Build an ordered zone cache for setting lookup
+            zones = ::Orchestrator::Control.instance.zones
+            @zones = []
+            @config.zones.each do |zone_id|
+                zone = zones[zone_id]
+                @zones << zone unless zone.nil?
+            end
+        end
+
+        def get(mod, index)
+            mods = @modules[mod]
+            if mods
+                mods[index]
+            else
+                nil # As subscriptions can be made to modules that don't exist
+            end
+        end
+
+        def all(mod)
+            @modules[mod] || []
+        end
+
+        def count(name)
+            mod = @modules[name.to_sym]
+            mod.nil? ? 0 : mod.length
+        end
+
+        def modules
+            @modules.keys
+        end
+
+        def settings
+            @config.settings
+        end
+
+
+        protected
+
+
+        # looks for the system in the database
+        def self.load(id)
+            @@critical.synchronize {
+                system = @@systems[id]
+                return system unless system.nil?
+
+                sys = ControlSystem.find_by_id(id.to_s)
+                if sys.nil?
+                    return nil
+                else
+                    system = System.new(sys)
+                    @@systems[id] = system
+                end
+                return system
+            }
+        end
+
+        def index_module(mod_id)
+            manager = @controller.loaded?(mod_id)
+            if manager
+                mod_name = if manager.settings.custom_name.nil?
+                    manager.settings.dependency.module_name.to_sym
+                else
+                    manager.settings.custom_name.to_sym
+                end
+                @modules[mod_name] ||= []
+                @modules[mod_name] << manager
+            end
+        end
+    end
+end

data/lib/orchestrator/utilities/constants.rb

@@ -0,0 +1,41 @@
+require 'set'
+
+
+module Orchestrator
+    module Constants
+        On = true       # On is active
+        Off = false     # Off is inactive
+        Down = true     # Down is usually active (projector screen for instance)
+        Up = false      # Up is usually inactive
+        Open = true
+        Close = false
+        Short = false
+
+        On_vars = Set.new([1, true, 'true', 'True', 
+                            :on, :On, 'on', 'On', 
+                            :yes, :Yes, 'yes', 'Yes', 
+                            'down', 'Down', :down, :Down, 
+                            'open', 'Open', :open, :Open])
+        Off_vars = Set.new([0, false, 'false', 'False',
+                            :off, :Off, 'off', 'Off', 
+                            :no, :No, 'no', 'No',
+                            'up', 'Up', :up, :Up,
+                            'close', 'Close', :close, :Close,
+                            'short', 'Short', :short, :Short])
+
+
+        def in_range(num, max, min = 0)
+            num = min if num < min
+            num = max if num > max
+            num
+        end
+
+        def is_affirmative?(val)
+            On_vars.include?(val)
+        end
+
+        def is_negatory?(val)
+            Off_vars.include?(val)
+        end
+    end
+end

data/lib/orchestrator/utilities/transcoder.rb

@@ -0,0 +1,57 @@
+module Orchestrator
+    module Transcoder
+        # Converts a hex encoded string into a binary string
+        #
+        # @param data [String] a hex encoded string
+        # @return [String]
+        def hex_to_byte(data)
+            # Removes invalid characters
+            data = data.gsub(/(0x|[^0-9A-Fa-f])*/, "")
+
+            # Ensure we have an even number of characters
+            data.prepend('0') if data.length % 2 > 0
+
+            # Breaks string into an array of characters
+            output = ""
+            data.scan(/.{2}/) { |byte| output << byte.hex}
+            return output
+        end
+        
+        # Converts a binary string into a hex encoded string
+        #
+        # @param data [String] a binary string
+        # @return [String]
+        def byte_to_hex(data)
+            output = ""
+            data.each_byte { |c|
+                s = c.to_s(16)
+                s.prepend('0') if s.length % 2 > 0
+                output << s
+            }
+            return output
+        end
+        
+        # Converts a string into an array of bytes
+        #
+        # @param data [String] data to be converted to bytes
+        # @return [Array]
+        def str_to_array(data)
+            data.bytes.to_a
+        end
+        
+        # Converts a byte array into a binary string
+        #
+        # @param data [Array] an array of bytes
+        # @return [String]
+        def array_to_str(data)
+            data.pack('c*')
+        end
+
+
+        # Makes the functions private when included
+        module_function :hex_to_byte
+        module_function :byte_to_hex
+        module_function :str_to_array
+        module_function :array_to_str
+    end
+end

data/lib/orchestrator/version.rb

@@ -0,0 +1,3 @@
+module Orchestrator
+    VERSION = "1.0.1"
+end

data/lib/orchestrator/websocket_manager.rb

@@ -0,0 +1,425 @@
+require 'set'
+require 'json'
+
+
+module Orchestrator
+    class WebsocketManager
+        def initialize(ws, user)
+            @ws = ws
+            @user = user
+            @loop = ws.loop
+
+            @bindings = ::ThreadSafe::Cache.new
+            @stattrak = @loop.observer
+            @notify_update = method(:notify_update)
+
+            @logger = ::Orchestrator::Logger.new(@loop, user)
+
+            @ws.progress method(:on_message)
+            @ws.finally method(:on_shutdown)
+            #@ws.on_open method(:on_open)
+
+            @accessed = ::Set.new
+            @access_log = ::Orchestrator::AccessLog.new
+            @access_log.user_id = @user.id
+        end
+
+
+        DECODE_OPTIONS = {
+            symbolize_names: true
+        }.freeze
+
+        PARAMS = [:id, :cmd, :sys, :mod, :index, :name, {args: [].freeze}.freeze].freeze
+        REQUIRED = [:id, :cmd, :sys, :mod, :name].freeze
+        COMMANDS = Set.new([:exec, :bind, :unbind, :debug, :ignore])
+
+        ERRORS = {
+            parse_error: 0,
+            bad_request: 1,
+            access_denied: 2,
+            request_failed: 3,
+            unknown_command: 4,
+
+            system_not_found: 5,
+            module_not_found: 6,
+            unexpected_failure: 7
+        }.freeze
+
+
+        protected
+
+
+        def on_message(data, ws)
+            if data == 'ping'
+                @ws.text('pong')
+                return
+            end
+
+            begin
+                raw_parameters = ::JSON.parse(data, DECODE_OPTIONS)
+                parameters = ::ActionController::Parameters.new(raw_parameters)
+                params = parameters.permit(PARAMS).tap do |whitelist|
+                    whitelist[:args] = parameters[:args]
+                end
+            rescue => e
+                @logger.print_error(e, 'error parsing websocket request')
+                error_response(nil, ERRORS[:parse_error], e.message)
+                return
+            end
+
+            if check_requirements(params)
+                # Perform the security check in a nonblocking fashion
+                # (Database access is probably required)
+                result = @loop.work do
+                    sys = params[:sys]
+                    params[:sys] = ::Orchestrator::ControlSystem.bucket.get("sysname-#{sys.downcase}", {quiet: true}) || sys
+                    Rails.configuration.orchestrator.check_access.call(params[:sys], @user)
+                end
+
+                # The result should be an access level if these are implemented
+                result.then do |access|
+                    begin
+                        cmd = params[:cmd].to_sym
+                        if COMMANDS.include?(cmd)
+                            @accessed << params[:sys]   # Log the access
+                            self.__send__(cmd, params)  # Execute the request
+                        else
+                            @access_log.suspected = true
+                            @logger.warn("websocket requested unknown command '#{params[:cmd]}'")
+                            error_response(params[:id], ERRORS[:unknown_command], "unknown command: #{params[:cmd]}")
+                        end
+                    rescue => e
+                        @logger.print_error(e, "websocket request failed: #{data}")
+                        error_response(params[:id], ERRORS[:request_failed], e.message)
+                    end
+                end
+
+                # Raise an error if access is not granted
+                result.catch do |err|
+                    @access_log.suspected = true
+                    @logger.print_error(e, 'security check failed for websocket request')
+                    error_response(params[:id], ERRORS[:access_denied], e.message)
+                end
+            else
+                # log user information here (possible probing attempt)
+                @access_log.suspected = true
+                reason = 'required parameters were missing from the request'
+                @logger.warn(reason)
+                error_response(params[:id], ERRORS[:bad_request], reason)
+            end
+        end
+
+        def check_requirements(params)
+            REQUIRED.each do |key|
+                return false if params[key].nil?
+            end
+            true
+        end
+
+
+        def exec(params)
+            id = params[:id]
+            sys = params[:sys]
+            mod = params[:mod].to_sym
+            name = params[:name].to_sym
+            index_s = params[:index] || 1
+            index = index_s.to_i
+
+            args = params[:args] || []
+
+            @loop.work do
+                do_exec(id, sys, mod, index, name, args)
+            end
+        end
+
+        def do_exec(id, sys, mod, index, name, args)
+            system = ::Orchestrator::System.get(sys)
+
+            if system
+                mod_man = system.get(mod, index - 1)
+                if mod_man
+                    req = Core::RequestProxy.new(@loop, mod_man)
+                    result = req.send(name, *args)
+                    result.then(proc { |res|
+                        output = nil
+                        begin
+                            ::JSON.generate([res])
+                            output = res
+                        rescue => e
+                            # respond with nil if object cannot be converted
+                            # TODO:: need a better way of dealing with this
+                            # ALSO in systems controller
+                        end
+                        @ws.text(::JSON.generate({
+                            id: id,
+                            type: :success,
+                            value: output
+                        }))
+                    }, proc { |err|
+                        # Request proxy will log the error
+                        error_response(id, ERRORS[:request_failed], err.message)
+                    })
+                else
+                    @logger.debug("websocket exec could not find module: {sys: #{sys}, mod: #{mod}, index: #{index}, name: #{name}}")
+                    error_response(id, ERRORS[:module_not_found], "could not find module: #{mod}")
+                end
+            else
+                @logger.debug("websocket exec could not find system: {sys: #{sys}, mod: #{mod}, index: #{index}, name: #{name}}")
+                error_response(id, ERRORS[:system_not_found], "could not find system: #{sys}")
+            end
+        end
+
+
+        def unbind(params)
+            id = params[:id]
+            sys = params[:sys]
+            mod = params[:mod]
+            name = params[:name]
+            index_s = params[:index] || 1
+            index = index_s.to_i
+
+            lookup = :"#{sys}_#{mod}_#{index}_#{name}"
+            binding = @bindings.delete(lookup)
+            do_unbind(binding) if binding
+
+            @ws.text(::JSON.generate({
+                id: id,
+                type: :success
+            }))
+        end
+
+        def do_unbind(binding)
+            @stattrak.unsubscribe(binding)
+        end
+
+
+        def bind(params)
+            id = params[:id]
+            sys = params[:sys]
+            mod = params[:mod].to_sym
+            name = params[:name].to_sym
+            index_s = params[:index] || 1
+            index = index_s.to_i
+
+            # perform binding on the thread pool
+            @loop.work(proc {
+                check_binding(id, sys, mod, index, name)
+            }).catch do |err|
+                @logger.print_error(err, "websocket request failed: #{params}")
+                error_response(id, ERRORS[:unexpected_failure], err.message)
+            end
+        end
+
+        # Called from a worker thread
+        def check_binding(id, sys, mod, index, name)
+            system = ::Orchestrator::System.get(sys)
+
+            if system
+                lookup = :"#{sys}_#{mod}_#{index}_#{name}"
+                binding = @bindings[lookup]
+
+                if binding.nil?
+                    try_bind(id, sys, system, mod, index, name, lookup)
+                else
+                    # binding already made - return success
+                    @ws.text(::JSON.generate({
+                        id: id,
+                        type: :success,
+                        meta: {
+                            sys: sys,
+                            mod: mod,
+                            index: index,
+                            name: name
+                        }
+                    }))
+                end
+            else
+                @logger.debug("websocket binding could not find system: {sys: #{sys}, mod: #{mod}, index: #{index}, name: #{name}}")
+                error_response(id, ERRORS[:system_not_found], "could not find system: #{sys}")
+            end
+        end
+
+        def try_bind(id, sys, system, mod_name, index, name, lookup)
+            options = {
+                sys_id: sys,
+                sys_name: system.config.name,
+                mod_name: mod_name,
+                index: index,
+                status: name,
+                callback: @notify_update,
+                on_thread: @loop
+            }
+
+            # if the module exists, subscribe on the correct thread
+            # use a bit of promise magic as required
+            mod_man = system.get(mod_name, index - 1)
+            defer = @loop.defer
+
+            # Ensure browser sees this before the first status update
+            # At this point subscription will be successful
+            @bindings[lookup] = defer.promise
+            @ws.text(::JSON.generate({
+                id: id,
+                type: :success,
+                meta: {
+                    sys: sys,
+                    mod: mod_name,
+                    index: index,
+                    name: name
+                }
+            }))
+
+            if mod_man
+                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
+            else
+                @loop.schedule do
+                    defer.resolve @stattrak.subscribe(options)
+                end
+            end
+        end
+
+        def notify_update(update)
+            output = nil
+            begin
+                ::JSON.generate([update.value])
+                output = update.value
+            rescue => e
+                # respond with nil if object cannot be converted
+                # TODO:: need a better way of dealing with this
+            end
+            @ws.text(::JSON.generate({
+                type: :notify,
+                value: output,
+                meta: {
+                    sys: update.sys_id,
+                    mod: update.mod_name,
+                    index: update.index,
+                    name: update.status
+                }
+            }))
+        end
+
+
+        def debug(params)
+            id = params[:id]
+            sys = params[:sys]
+            mod_s = params[:mod]
+            mod = mod_s.to_sym if mod_s
+
+            if @debug.nil?
+                @debug = @loop.defer
+                @inspecting = Set.new # modules
+                @debug.promise.progress method(:debug_update)
+            end
+
+            # Set mod to get module level errors
+            if mod && !@inspecting.include?(mod)
+                mod_man = ::Orchestrator::Control.instance.loaded?(mod)
+                if mod_man
+                    log = mod_man.logger
+                    log.add @debug
+                    log.level = :debug
+                    @inspecting.add mod
+
+                    # Set sys to get errors occurring outside of the modules
+                    if !@inspecting.include?(:self)
+                        @logger.add @debug
+                        @logger.level = :debug
+                        @inspecting.add :self
+                    end
+
+                    @ws.text(::JSON.generate({
+                        id: id,
+                        type: :success
+                    }))
+                else
+                    @logger.info("websocket debug could not find module: #{mod}")
+                    error_response(id, ERRORS[:module_not_found], "could not find module: #{mod}")
+                end
+            else
+                @ws.text(::JSON.generate({
+                    id: id,
+                    type: :success
+                }))
+            end
+        end
+
+        def debug_update(klass, id, level, msg)
+            @ws.text(::JSON.generate({
+                type: :debug,
+                mod: id,
+                klass: klass,
+                level: level,
+                msg: msg
+            }))
+        end
+
+
+        def ignore(params)
+            id = params[:id]
+            sys = params[:sys]
+            mod_s = params[:mod]
+            mod = mod_s.to_sym if mod_s
+
+            if @debug.nil?
+                @debug = @loop.defer
+                @inspecting = Set.new # modules
+                @debug.promise.progress method(:debug_update)
+            end
+
+            # Remove module level errors
+            if mod && @inspecting.include?(mod)
+                mod_man = ::Orchestrator::Control.instance.loaded?(mod)
+                if mod_man
+                    mod_man.logger.delete @debug
+                    @inspecting.delete mod
+
+                    # Stop logging all together if no more modules being watched
+                    if @inspecting.empty?
+                        @logger.delete @debug
+                        @inspecting.delete :self
+                    end
+
+                    @ws.text(::JSON.generate({
+                        id: id,
+                        type: :success
+                    }))
+                else
+                    @logger.info("websocket ignore could not find module: #{mod}")
+                    error_response(id, ERRORS[:module_not_found], "could not find module: #{mod}")
+                end
+            else
+                @ws.text(::JSON.generate({
+                    id: id,
+                    type: :success
+                }))
+            end
+        end
+
+
+        def error_response(id, code, message)
+            @ws.text(::JSON.generate({
+                id: id,
+                type: :error,
+                code: code,
+                msg: message
+            }))
+        end
+
+        def on_shutdown
+            @bindings.each_value &method(:do_unbind)
+            @bindings = nil
+            @debug.resolve(true) if @debug # detach debug listeners
+
+            @access_log.systems = @accessed.to_a
+            @access_log.save
+        end
+    end
+end