orchestrator 1.0.2 → 1.0.3

data/lib/orchestrator/core/request_proxy.rb

@@ -45,11 +45,17 @@ module Orchestrator
 
 
         class RequestProxy
-            def initialize(thread, mod)
+            def initialize(thread, mod, user = nil)
                 @mod = mod
                 @thread = thread
+                @user = user
+                @trace = []
             end
 
+
+            attr_reader :trace
+
+
             # Simplify access to status variables as they are thread safe
             def [](name)
                 @mod.instance[name]
@@ -77,6 +83,11 @@ module Orchestrator
                 end
             end
 
+            # Looks up the arity of a method
+            def arity(method)
+                @mod.instance.method(method.to_sym).arity
+            end
+
             # All other method calls are wrapped in a promise
             def method_missing(name, *args, &block)
                 defer = @thread.defer
@@ -90,14 +101,25 @@ module Orchestrator
                     defer.reject(err)
                     @mod.logger.warn(err.message)
                 else
+                    @trace = caller
+
                     @mod.thread.schedule do
+                        # Keep track of previous in case of recursion
+                        previous = nil
                         begin
+                            if @user
+                                previous = @mod.current_user
+                                @mod.current_user = @user
+                            end
+                            
                             defer.resolve(
                                 @mod.instance.public_send(name, *args, &block)
                             )
                         rescue => e
-                            @mod.logger.print_error(e)
+                            @mod.logger.print_error(e, '', @trace)
                             defer.reject(e)
+                        ensure
+                            @mod.current_user = previous if @user
                         end
                     end
                 end

data/lib/orchestrator/core/requests_proxy.rb

@@ -1,22 +1,65 @@
+require 'forwardable'
+
 module Orchestrator
     module Core
         class RequestsProxy
-            def initialize(thread, modules)
+            extend Forwardable
+
+            
+            def initialize(thread, modules, user = nil)
                 if modules.nil?
                     @modules = []
                 else
                     @modules = modules.is_a?(Array) ? modules : [modules]
                 end
                 @thread = thread
+                @user = user
+                @trace = []
+            end
+
+
+            attr_reader :trace
+
+
+            # Provide Enumerable support
+            def each
+                return enum_for(:each) unless block_given?
+
+                @modules.each do |mod|
+                    yield RequestProxy.new(@thread, mod, @user)
+                end
             end
 
+            # Provide some helper methods
+            def_delegators :@modules, :count, :length, :empty?, :each_index
+
+            def last
+                mod = @modules.last
+                return nil unless mod
+                return RequestProxy.new(@thread, mod, @user)
+            end
+
+            def first
+                mod = @modules.first
+                return nil unless mod
+                return RequestProxy.new(@thread, mod, @user)
+            end
+
+            def [](index)
+                mod = @modules[index]
+                return nil unless mod
+                return RequestProxy.new(@thread, mod, @user)
+            end
+            alias_method :at, :[]
+
             # Returns true if there is no object to proxy
+            # Allows RequestProxy and RequestsProxy to be used interchangably
             #
             # @return [true|false]
             def nil?
                 @modules.empty?
             end
-            alias_method :empty?, :nil?
+
 
             def method_missing(name, *args, &block)
                 if ::Orchestrator::Core::PROTECTED[name]
@@ -24,16 +67,27 @@ module Orchestrator
                     ::Libuv::Q.reject(@thread, err)
                     # TODO:: log warning err.message
                 else
+                    @trace = caller
+
                     promises = @modules.map do |mod|
                         defer = mod.thread.defer
                         mod.thread.schedule do
+                            # Keep track of previous in case of recursion
+                            previous = nil
                             begin
+                                if @user
+                                    previous = mod.current_user
+                                    mod.current_user = @user
+                                end
+
                                 defer.resolve(
                                     mod.instance.public_send(name, *args, &block)
                                 )
                             rescue => e
-                                mod.logger.print_error(e)
+                                mod.logger.print_error(e, '', @trace)
                                 defer.reject(e)
+                            ensure
+                                mod.current_user = previous if @user
                             end
                         end
                         defer.promise

data/lib/orchestrator/core/system_proxy.rb

@@ -4,10 +4,11 @@ require 'set'
 module Orchestrator
     module Core
         class SystemProxy
-            def initialize(thread, sys_id, origin = nil)
+            def initialize(thread, sys_id, origin = nil, user = nil)
                 @system = sys_id.to_sym
                 @thread = thread
                 @origin = origin    # This is the module that requested the proxy
+                @user = user
             end
 
             # Alias for get
@@ -24,7 +25,7 @@ module Orchestrator
                 index -= 1  # Get the real index
                 name = mod.to_sym
 
-                RequestProxy.new(@thread, system.get(name, index))
+                RequestProxy.new(@thread, system.get(name, index), @user)
             end
 
             # Checks for the existence of a particular module
@@ -44,8 +45,7 @@ module Orchestrator
             # @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))
+                RequestsProxy.new(@thread, system.all(mod.to_sym), @user)
             end
 
             # Iterates over the modules in the system. Can also specify module types.
@@ -67,8 +67,7 @@ module Orchestrator
             # @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)
+                system.count(mod.to_sym)
             end
 
             # Returns a list of all the module names in the system
@@ -85,6 +84,13 @@ module Orchestrator
                 system.config.name
             end
 
+            # Returns the system id as defined in the database
+            #
+            # @return [Symbol] the id of the system
+            def id
+                @system
+            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

data/lib/orchestrator/device/processor.rb

@@ -34,6 +34,7 @@ module Orchestrator
                 # Other options include:
                 # * emit callback to occur once command complete (may be discarded if a named command)
                 # * on_receive (alternative to received function)
+                # * clear_queue (clear further commands once this has run)
             }
 
             CONFIG_DEFAULTS = {
@@ -425,6 +426,12 @@ module Orchestrator
                     command[:defer].resolve(:no_wait)
                     call_emit command   # the command has been sent
                 end
+
+                # Useful for emergency stops etc
+                if command[:clear_queue]
+                    @queue.cancel_all("Command #{command[:name]} cleared the queue")
+                end
+
                 nil # ensure promise chain is not propagated
             end
 

data/lib/orchestrator/engine.rb

@@ -36,6 +36,7 @@ module Orchestrator
         # Discover the possible module location paths after initialization is complete
         #
         config.after_initialize do |app|
+            require File.expand_path(File.join(File.expand_path("../", __FILE__), '../../app/models/user'))
             
             ActiveSupport::Dependencies.autoload_paths.each do |path|
                 Pathname.new(path).ascend do |v|

data/lib/orchestrator/logger.rb

@@ -87,9 +87,10 @@ module Orchestrator
             end
         end
 
-        def print_error(e, msg = '')
+        def print_error(e, msg = '', trace = nil)
             msg << "\n#{e.message}"
             msg << "\n#{e.backtrace.join("\n")}" if e.respond_to?(:backtrace) && e.backtrace
+            msg << "\nCaller backtrace:\n#{trace.join("\n")}" if trace
             error(msg)
         end
 

data/lib/orchestrator/logic/manager.rb

@@ -10,8 +10,8 @@ module Orchestrator
             end
 
             # Access to other modules in the same control system
-            def system
-                @system ||= ::Orchestrator::Core::SystemProxy.new(@thread, @settings.control_system_id)
+            def system(user = nil)
+                ::Orchestrator::Core::SystemProxy.new(@thread, @settings.control_system_id, nil, user)
             end
         end
     end

data/lib/orchestrator/logic/mixin.rb

@@ -4,7 +4,7 @@ module Orchestrator
             include ::Orchestrator::Core::Mixin
 
             def system
-                @__config__.system
+                @__config__.system(current_user)
             end
         end
     end

data/lib/orchestrator/remote/edge.rb

@@ -0,0 +1,30 @@
+require 'set'
+
+
+module Orchestrator
+
+    class Edge
+        def initialize(edge_ip, thread)
+            @thread = thread
+            @ip = edge_ip
+
+            reconnect
+        end
+
+
+        attr_reader :thread
+
+
+        def exec()
+
+        end
+
+
+        protected
+
+
+        def reconnect
+            
+        end
+    end
+end

data/lib/orchestrator/remote/master.rb

@@ -0,0 +1,150 @@
+require 'set'
+require 'json'
+
+
+module Orchestrator
+
+    class Master
+        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
+            @requests   = {} # req_id => defer
+            @req_map    = {} # connection => ::Set.new (req_id)
+
+            @signal_bind   = @thread.async method(:bind_actual)
+            @signal_unbind = @thread.async method(:unbind_actual)
+
+            @request_id = 0
+        end
+
+
+        attr_reader :thread
+
+
+        # ping
+        # pong
+        # exec
+        # bind
+        # unbind
+        # notify
+        # status
+        # success
+        # failure
+
+
+        def request(edge_id, details)
+            defer = @thread.defer
+
+            # Lookup node
+            connection = online? id
+            if connection
+                @thread.schedule do
+                    if connection.connected
+                        @request_id += 1
+                        @requests[@request_id] = defer
+                        @req_map[connection] ||= ::Set.new
+                        @req_map[connection] << @request_id
+                        
+                        # Send the request
+                        connection.write(::JSON.fast_generate({
+                            id: @request_id,
+
+                        })).catch do |reason|
+                            on_failure(defer, edge_id, details)
+                        end
+                    else
+                        on_failure(defer, edge_id, details)
+                    end
+                end
+            else
+                on_failure(defer, edge_id, details)
+            end
+
+            defer.promise
+        end
+
+        def online?(id)
+            edge = @edge_nodes[id]
+            edge && edge.connected ? edge : false
+        end
+
+        def unbind
+            @signal_unbind.call
+        end
+
+        def bind
+            @signal_bind.call
+        end
+
+        
+        protected
+
+
+        def on_failure(defer, edge_id, details)
+            # Failed...
+            # Are we loading this device locally or remotely?
+            # Do we wait a small amount of time before trying again?
+            # When should we fail the request?
+        end
+
+
+        # These are async methods.. They could be called more than once
+        def unbind_actual(*args)
+            return if @shutdown
+            @shutdown = true
+
+            @tcp.close unless @tcp.nil?
+            @tcp = nil
+        end
+
+        def bind_actual(*args)
+            return unless @shutdown
+            @shutdown = false
+
+            # Bind the socket
+            @tcp = @thread.tcp
+            @tcp.bind '0.0.0.0', 17838, @new_connection
+            @tcp.listen 100 # smallish backlog is all we need
+
+            # Delegate errors
+            @tcp.catch @bind_error
+            @tcp
+        end
+
+
+        # There is a new connection pending. We accept it
+        def new_connection(server)
+            server.accept @accept_connection
+        end
+
+        # Once the connection is accepted we disable Nagles Algorithm
+        # This improves performance as we are using vectored or scatter/gather IO
+        # Then the spider delegates to the gazelle loops
+        def accept_connection(client)
+            client.enable_nodelay
+            # TODO:: auth client and then signal the interested parties
+        end
+
+        # Called when binding is closed due to an error
+        def bind_error(err)
+            return if @shutdown
+
+            # TODO:: log the error
+
+            # Attempt to recover!
+            @thread.scheduler.in(1000) do
+                bind
+            end
+        end
+
+        def process_request(defer, node, request)
+
+        end
+    end
+end