orchestrator 1.0.2 → 1.0.3

data/lib/orchestrator/remote/proxy.rb

@@ -0,0 +1,24 @@
+require 'set'
+
+
+module Orchestrator
+    class Proxy
+        COMMANDS = Set.new([:exec, :bind, :unbind, :debug, :ignore])
+        
+        def initialize(thread)
+            @thread = thread
+
+            @accept_connection = method :accept_connection
+            @new_connection =    method :new_connection
+            @bind_error =        method :bind_error
+
+            @shutdown = true
+            @edge_nodes = ::ThreadSafe::Cache.new # id => connection
+            @req_map    = {} # connection => ::Set.new (defers)
+            @req_map    = {}
+
+            @signal_bind   = @thread.async method(:bind_actual)
+            @signal_unbind = @thread.async method(:unbind_actual)
+        end
+    end
+end

data/lib/orchestrator/status.rb

@@ -97,12 +97,42 @@ module Orchestrator
             end
         end
 
-        # TODO:: we also need the system class to contact each of the threads
-        def reloaded_system(sys_id)
+        # Used to maintain subscriptions where module is moved to another thread
+        # or even another server.
+        def move(mod_id, to_thread)
+            return if to_thread == self
+
+            @thread.schedule do
+                subs = @subscriptions.delete(mod_id)
+                if subs
+                    # Remove the system references
+                    subs.each do |sub|
+                        @systems[sub.sys_id].delete(sub) if sub.sys_id
+                    end
+
+                    # Transfer the subscriptions
+                    to_thread.transfer(mod_id, subs)
+                end
+            end
+        end
+
+        def transfer(mod_id, subs)
+            @thread.schedule do
+                @subscriptions[mod_id] = subs
+
+                subs.each do |sub|
+                    if sub.sys_id
+                        @systems[sub.sys_id] ||= Set.new
+                        @systems[sub.sys_id] << sub
+                    end
+                end
+            end
+        end
+
+        # The System class contacts each of the threads to let them know of an update
+        def reloaded_system(sys_id, sys)
             subscriptions = @systems[sys_id]
             if subscriptions
-                sys = ::Orchestrator::System.get(@system)
-
                 subscriptions.each do |sub|
                     old_id = sub.mod_id
 
@@ -125,6 +155,11 @@ module Orchestrator
                             sub.notify(value) unless value.nil?
                         end
 
+                        # Transfer the subscription if on a different thread
+                        if mod.thread != @thread
+                            move(sub.mod_id.to_sym, mod.thread)
+                        end
+
                         # Perform any required cleanup
                         if @subscriptions[old_id][sub.status].empty?
                             @subscriptions[old_id].delete(sub.status)

data/lib/orchestrator/system.rb

@@ -43,6 +43,14 @@ module Orchestrator
                 zone = zones[zone_id]
                 @zones << zone unless zone.nil?
             end
+
+            # Inform status tracker that that the system has reloaded
+            # There may have been a change in module order etc
+            @controller.threads.each do |thread|
+                thread.next_tick do
+                    thread.observer.reloaded_system(@config.id, self)
+                end
+            end
         end
 
         def get(mod, index)

data/lib/orchestrator/utilities/constants.rb

@@ -15,13 +15,15 @@ module Orchestrator
                             :on, :On, 'on', 'On', 
                             :yes, :Yes, 'yes', 'Yes', 
                             'down', 'Down', :down, :Down, 
-                            'open', 'Open', :open, :Open])
+                            'open', 'Open', :open, :Open,
+                            'active', 'Active', :active, :Active])
         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])
+                            'short', 'Short', :short, :Short,
+                            'inactive', 'Inactive', :inactive, :Inactive])
 
 
         def in_range(num, max, min = 0)

data/lib/orchestrator/utilities/transcoder.rb

@@ -12,9 +12,9 @@ module Orchestrator
             data.prepend('0') if data.length % 2 > 0
 
             # Breaks string into an array of characters
-            output = ""
+            output = []
             data.scan(/.{2}/) { |byte| output << byte.hex}
-            return output
+            output.pack('c*')
         end
         
         # Converts a binary string into a hex encoded string
@@ -22,6 +22,8 @@ module Orchestrator
         # @param data [String] a binary string
         # @return [String]
         def byte_to_hex(data)
+            data = array_to_str(data) if data.is_a? Array
+
             output = ""
             data.each_byte { |c|
                 s = c.to_s(16)
@@ -36,6 +38,7 @@ module Orchestrator
         # @param data [String] data to be converted to bytes
         # @return [Array]
         def str_to_array(data)
+            return data if data.is_a? Array
             data.bytes.to_a
         end
         
@@ -44,6 +47,7 @@ module Orchestrator
         # @param data [Array] an array of bytes
         # @return [String]
         def array_to_str(data)
+            return data if data.is_a? String
             data.pack('c*')
         end
 

data/lib/orchestrator/version.rb

@@ -1,3 +1,3 @@
 module Orchestrator
-    VERSION = "1.0.2"
+    VERSION = "1.0.3"
 end

data/lib/orchestrator/websocket_manager.rb

@@ -83,6 +83,9 @@ module Orchestrator
                         if COMMANDS.include?(cmd)
                             @accessed << params[:sys]   # Log the access
                             self.__send__(cmd, params)  # Execute the request
+
+                            # Start logging
+                            periodicly_update_logs if @accessTimer.nil?
                         else
                             @access_log.suspected = true
                             @logger.warn("websocket requested unknown command '#{params[:cmd]}'")
@@ -95,7 +98,7 @@ module Orchestrator
                 end
 
                 # Raise an error if access is not granted
-                result.catch do |err|
+                result.catch do |e|
                     @access_log.suspected = true
                     @logger.print_error(e, 'security check failed for websocket request')
                     error_response(params[:id], ERRORS[:access_denied], e.message)
@@ -111,7 +114,7 @@ module Orchestrator
 
         def check_requirements(params)
             REQUIRED.each do |key|
-                return false if params[key].nil?
+                return false unless params.has_key?(key)
             end
             true
         end
@@ -138,7 +141,7 @@ module Orchestrator
             if system
                 mod_man = system.get(mod, index - 1)
                 if mod_man
-                    req = Core::RequestProxy.new(@loop, mod_man)
+                    req = Core::RequestProxy.new(@loop, mod_man, @user)
                     result = req.send(name, *args)
                     result.then(proc { |res|
                         output = nil
@@ -310,8 +313,10 @@ module Orchestrator
         def debug(params)
             id = params[:id]
             sys = params[:sys]
-            mod_s = params[:mod]
-            mod = mod_s.to_sym if mod_s
+            mod = params[:mod].to_sym
+            index_s = params[:index]
+            index = nil
+            index = index_s.to_i if index_s
 
             if @debug.nil?
                 @debug = @loop.defer
@@ -319,35 +324,82 @@ module Orchestrator
                 @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
+            if index
+                # Look up the module ID on the thread pool
+                @loop.work(proc {
+                    system = ::Orchestrator::System.get(sys)
+                    if system
+                        mod_man = system.get(mod, index - 1)
+                        if mod_man
+                            mod_man.settings.id
+                        else
+                            ::Libuv::Q.reject(@loop, 'debug failed: module #{sys}->#{mod}_#{index} not found')
+                        end
+                    else
+                        ::Libuv::Q.reject(@loop, 'debug failed: system #{sys} lookup failed')
                     end
+                }).then(proc { |mod_id|
+                    do_debug(id, mod_id, sys, mod, index)
+                }).catch do |err|
+                    if err.is_a? String
+                        @logger.info(err)
+                        error_response(id, ERRORS[:module_not_found], err)
+                    else
+                        @logger.print_error(err, "debug request failed: #{params}")
+                        error_response(id, ERRORS[:module_not_found], "debug request failed for: #{sys}->#{mod}_#{index}")
+                    end
+                end
+            else
+                do_debug(id, mod)
+            end
+        end
 
-                    @ws.text(::JSON.generate({
-                        id: id,
-                        type: :success
-                    }))
+        def do_debug(id, mod, sys_id = nil, mod_name = nil, mod_index = nil)
+            resp = {
+                id: id,
+                type: :success,
+                mod_id: mod
+            }
+
+            if mod_name
+                # Provide meta information for convenience
+                # Actual debug messages do not contain this info
+                # The library must use the mod_id returned in the response to route responses as desired
+                resp[:meta] = {
+                    sys: sys_id,
+                    mod: mod_name,
+                    index: mod_index
+                }
+            end
+
+            # Set mod to get module level errors
+            begin
+                if @inspecting.include?(mod)
+                    @ws.text(::JSON.generate(resp))
                 else
-                    @logger.info("websocket debug could not find module: #{mod}")
-                    error_response(id, ERRORS[:module_not_found], "could not find module: #{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(resp))
+                    else
+                        @logger.info("websocket debug could not find module: #{mod}")
+                        error_response(id, ERRORS[:module_not_found], "could not find module: #{mod}")
+                    end
                 end
-            else
-                @ws.text(::JSON.generate({
-                    id: id,
-                    type: :success
-                }))
+            rescue => e
+                @logger.print_error(e, "websocket debug request failed")
+                error_response(id, ERRORS[:request_failed], e.message)
             end
         end
 
@@ -418,8 +470,46 @@ module Orchestrator
             @bindings = nil
             @debug.resolve(true) if @debug # detach debug listeners
 
+            @accessTimer.cancel
+            @loop.work(proc {
+                @accesslock.synchronize {
+                    @access_log.systems = @accessed.to_a
+                    @access_log.ended_at = Time.now.to_i
+                    @access_log.save
+                }
+            })
+        end
+
+
+        protected
+
+
+        def update_accessed(*args)
+            if @accesslock.try_lock    # No blocking!
+                begin
+                    @access_log.systems = @accessed.to_a
+
+                    @loop.work(proc {
+                        @access_log.save
+                    }).finally do
+                        @accesslock.unlock
+                    end
+                rescue => e
+                    @accesslock.unlock if @accesslock.locked?
+                    @logger.print_error(e, "unknown error writing access log")
+                end
+            end
+        end
+
+        def periodicly_update_logs
+            @accessTimer = @loop.scheduler.every(60000 + Random.rand(1000), method(:update_accessed))
+            @accesslock = Mutex.new
             @access_log.systems = @accessed.to_a
-            @access_log.save
+            @loop.work(proc {
+                @accesslock.synchronize {
+                    @access_log.save
+                }
+            })
         end
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: orchestrator
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-19 00:00:00.000000000 Z
+date: 2015-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -190,8 +190,10 @@ files:
 - README.md
 - Rakefile
 - app/controllers/orchestrator/api/dependencies_controller.rb
+- app/controllers/orchestrator/api/logs_controller.rb
 - app/controllers/orchestrator/api/modules_controller.rb
 - app/controllers/orchestrator/api/systems_controller.rb
+- app/controllers/orchestrator/api/users_controller.rb
 - app/controllers/orchestrator/api/zones_controller.rb
 - app/controllers/orchestrator/api_controller.rb
 - app/controllers/orchestrator/base.rb
@@ -199,6 +201,7 @@ files:
 - app/models/orchestrator/access_log.rb
 - app/models/orchestrator/control_system.rb
 - app/models/orchestrator/dependency.rb
+- app/models/orchestrator/edge_control.rb
 - app/models/orchestrator/mod/by_dependency/map.js
 - app/models/orchestrator/mod/by_module_type/map.js
 - app/models/orchestrator/module.rb
@@ -206,6 +209,7 @@ files:
 - app/models/orchestrator/sys/by_zones/map.js
 - app/models/orchestrator/zone.rb
 - app/models/orchestrator/zone/all/map.js
+- app/models/user.rb
 - config/routes.rb
 - lib/generators/module/USAGE
 - lib/generators/module/module_generator.rb
@@ -231,6 +235,9 @@ files:
 - lib/orchestrator/logger.rb
 - lib/orchestrator/logic/manager.rb
 - lib/orchestrator/logic/mixin.rb
+- lib/orchestrator/remote/edge.rb
+- lib/orchestrator/remote/master.rb
+- lib/orchestrator/remote/proxy.rb
 - lib/orchestrator/service/manager.rb
 - lib/orchestrator/service/mixin.rb
 - lib/orchestrator/service/transport_http.rb
@@ -262,7 +269,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A distributed system for building automation