orchestrator 1.0.1

data/app/controllers/orchestrator/api/systems_controller.rb

@@ -0,0 +1,294 @@
+
+module Orchestrator
+    module Api
+        class SystemsController < ApiController
+            respond_to :json
+            # state, funcs, count and types are available to authenticated users
+            before_action :check_admin,   only: [:create, :update, :destroy, :remove, :start, :stop]
+            before_action :check_support, only: [:index, :show, :exec]
+            before_action :find_system,   only: [:show, :update, :destroy, :remove, :start, :stop]
+
+
+            @@elastic ||= Elastic.new(ControlSystem)
+
+
+            def index
+                query = @@elastic.query(params)
+                query.sort = [{name: "asc"}]
+
+                # Filter systems via zone_id
+                if params.has_key? :zone_id
+                    zone_id = params.permit(:zone_id)[:zone_id]
+                    query.filter({
+                        zones: [zone_id]
+                    })
+                end
+
+                # filter via module_id
+                if params.has_key? :module_id
+                    module_id = params.permit(:module_id)[:module_id]
+                    query.filter({
+                        modules: [module_id]
+                    })
+                end
+
+                respond_with @@elastic.search(query)
+            end
+
+            def show
+                if params.has_key? :complete
+                    respond_with @cs, {
+                        methods: [:module_data, :zone_data]
+                    }
+                else
+                    respond_with @cs
+                end
+            end
+
+            def update
+                @cs.update(safe_params)
+                #save_and_respond(@cs) # save deletes the system cache
+                respond_with :api, @cs
+            end
+
+            # Removes the module from the system and deletes it if not used elsewhere
+            def remove
+                module_id = params.permit(:module_id)[:module_id]
+                mod = ::Orchestrator::Module.find module_id
+
+                if @cs.modules.include? module_id
+                    remove = true
+
+                    @cs.modules.delete(module_id)
+                    @cs.save!
+
+                    ControlSystem.using_module(module_id).each do |cs|
+                        if cs.id != @cs.id
+                            remove = false
+                            break
+                        end
+                    end
+
+                    mod.delete if remove
+                end
+                render :nothing => true
+            end
+
+            def create
+                cs = ControlSystem.new(safe_params)
+                save_and_respond cs
+            end
+
+            def destroy
+                @cs.delete # expires the cache in after callback
+                render :nothing => true
+            end
+
+
+            ##
+            # Additional Functions:
+            ##
+
+            def start
+                # Start all modules in the system
+                @cs.modules.each do |mod_id|
+                    load_and_start mod_id
+                end
+                render :nothing => true
+            end
+
+            def stop
+                # Stop all modules in the system (shared or not)
+                @cs.modules.each do |mod_id|
+                    mod = control.loaded? mod_id
+                    if mod
+                        mod.thread.next_tick do
+                            mod.stop
+                        end
+                    end
+                end
+                render :nothing => true
+            end
+
+            def exec
+                # Run a function in a system module (async request)
+                params.require(:module)
+                params.require(:method)
+                sys = System.get(id)
+                if sys
+                    para = params.permit(:module, :index, :method, {args: []}).tap do |whitelist|
+                        whitelist[:args] = params[:args]
+                    end
+                    index = para[:index]
+                    mod = sys.get(para[:module].to_sym, index.nil? ? 0 : (index.to_i - 1))
+                    if mod
+                        mod.thread.schedule do
+                            perform_exec(mod, para)
+                        end
+                        throw :async
+                    else
+                        render nothing: true, status: :not_found
+                    end
+                else
+                    render nothing: true, status: :not_found
+                end
+            end
+
+            def state
+                # Status defined as a system module
+                params.require(:module)
+                params.require(:lookup)
+                sys = System.get(id)
+                if sys
+                    para = params.permit(:module, :index, :lookup)
+                    index = para[:index]
+                    mod = sys.get(para[:module].to_sym, index.nil? ? 0 : (index.to_i - 1))
+                    if mod
+                        render json: mod.status[para[:lookup].to_sym]
+                    else
+                        render nothing: true, status: :not_found
+                    end
+                else
+                    render nothing: true, status: :not_found
+                end
+            end
+
+            # returns a list of functions available to call
+            def funcs
+                params.require(:module)
+                sys = System.get(id)
+                if sys
+                    para = params.permit(:module, :index)
+                    index = para[:index]
+                    index = index.nil? ? 0 : (index.to_i - 1);
+
+                    mod = sys.get(para[:module].to_sym, index)
+                    if mod
+                        funcs = mod.instance.public_methods(false)
+                        priv = []
+                        funcs.each do |func|
+                            if ::Orchestrator::Core::PROTECTED[func]
+                                priv << func
+                            end
+                        end
+                        render json: (funcs - priv)
+                    else
+                        render nothing: true, status: :not_found
+                    end
+                else
+                    render nothing: true, status: :not_found
+                end
+            end
+
+            # return the count of a module type in a system
+            def count
+                params.require(:module)
+                sys = System.get(id)
+                if sys
+                    mod = params.permit(:module)[:module]
+                    render json: {count: sys.count(mod)}
+                else
+                    render nothing: true, status: :not_found
+                end
+            end
+
+            # return the list of a module types in a system
+            def types
+                sys = System.get(id)
+                if sys
+                    render json: sys.modules
+                else
+                    render nothing: true, status: :not_found
+                end
+            end
+
+
+            protected
+
+
+            # Better performance as don't need to create the object each time
+            CS_PARAMS = [
+                :name, :description, :support_url,
+                {
+                    zones: [],
+                    modules: []
+                }
+            ]
+            # We need to support an arbitrary settings hash so have to
+            # work around safe params as per 
+            # http://guides.rubyonrails.org/action_controller_overview.html#outside-the-scope-of-strong-parameters
+            def safe_params
+                settings = params[:settings]
+                {
+                    modules: [],
+                    zones: [],
+                    settings: settings.is_a?(::Hash) ? settings : {}
+                }.merge(params.permit(CS_PARAMS))
+            end
+
+            def find_system
+                # Find will raise a 404 (not found) if there is an error
+                sys = ::Orchestrator::ControlSystem.bucket.get("sysname-#{id.downcase}", {quiet: true}) || id
+                @cs = ControlSystem.find(sys)
+            end
+
+            def load_and_start(mod_id)
+                mod = control.loaded? mod_id
+                if mod
+                    mod.thread.next_tick do
+                        mod.start
+                    end
+                else # attempt to load module
+                    config = ::Orchestrator::Module.find(mod_id)
+                    control.load(config).then(
+                        proc { |mod|
+                            mod.thread.next_tick do
+                                mod.start
+                            end
+                        }
+                    )
+                end
+            end
+
+            # Called on the module thread
+            def perform_exec(mod, para)
+                defer = mod.thread.defer
+
+                req = Core::RequestProxy.new(mod.thread, mod)
+                args = para[:args] || []
+                result = req.send(para[:method].to_sym, *args)
+
+                # timeout in case message is queued
+                timeout = mod.thread.scheduler.in(5000) do
+                    defer.resolve('Wait time exceeded. Command may have been queued.')
+                end
+
+                result.finally do
+                    timeout.cancel # if we have our answer
+                    defer.resolve(result)
+                end
+
+                defer.promise.then(proc { |res|
+                    output = ''
+                    begin
+                        output = ::JSON.generate([res])
+                    rescue Exception => e
+                        # respond with nil if object cannot be converted
+                        # TODO:: need a better way of dealing with this
+                        # ALSO in websocket manager
+                    end
+                    env['async.callback'].call([200, {
+                        'Content-Length' => output.bytesize,
+                        'Content-Type' => 'application/json'
+                    }, [output]])
+                }, proc { |err|
+                    output = err.message
+                    env['async.callback'].call([500, {
+                        'Content-Length' => output.bytesize,
+                        'Content-Type' => 'text/plain'
+                    }, [output]])
+                })
+            end
+        end
+    end
+end

data/app/controllers/orchestrator/api/zones_controller.rb

@@ -0,0 +1,62 @@
+
+module Orchestrator
+    module Api
+        class ZonesController < ApiController
+            respond_to :json
+            before_action :check_admin
+            before_action :find_zone, only: [:show, :update, :destroy]
+
+
+            @@elastic ||= Elastic.new(Zone)
+
+
+            def index
+                query = @@elastic.query(params)
+                query.sort = [{name: "asc"}]
+
+                respond_with @@elastic.search(query)
+            end
+
+            def show
+                respond_with @zone
+            end
+
+            def update
+                @zone.update_attributes(safe_params)
+                save_and_respond @zone
+            end
+
+            def create
+                zone = Zone.new(safe_params)
+                save_and_respond zone
+            end
+
+            def destroy
+                # delete will update CS and zone caches
+                @zone.delete
+                render :nothing => true
+            end
+
+
+            protected
+
+
+            ZONE_PARAMS = [
+                :name, :description,
+                {groups: []}
+            ]
+            def safe_params
+                settings = params[:settings]
+                {
+                    settings: settings.is_a?(::Hash) ? settings : {},
+                    groups: []
+                }.merge(params.permit(ZONE_PARAMS))
+            end
+
+            def find_zone
+                # Find will raise a 404 (not found) if there is an error
+                @zone = Zone.find(id)
+            end
+        end
+    end
+end

data/app/controllers/orchestrator/api_controller.rb

@@ -0,0 +1,13 @@
+
+module Orchestrator
+    class ApiController < ::AcaEngineBase
+
+        protected
+
+
+        # Access to the control system controller
+        def control
+            @@__control__ ||= ::Orchestrator::Control.instance
+        end
+    end
+end

data/app/controllers/orchestrator/base.rb

@@ -0,0 +1,59 @@
+
+module Orchestrator
+    class Base < ::ActionController::Base
+        layout nil
+        rescue_from Couchbase::Error::NotFound, with: :entry_not_found
+
+
+        # Add headers to allow for CORS requests to the API
+        before_filter :allow_cors
+
+
+        # This is a preflight OPTIONS request
+        def options
+            render nothing: true
+        end
+
+
+        protected
+
+
+        # Don't keep re-creating these objects for every request
+        ALLOW_ORIGIN = 'Access-Control-Allow-Origin'.freeze
+        ALLOW_METHODS = 'Access-Control-Allow-Methods'.freeze
+        ALLOW_HEADERS = 'Access-Control-Allow-Headers'.freeze
+        MAX_AGE = 'Access-Control-Max-Age'.freeze
+        ANY_ORIGIN = '*'.freeze
+        ANY_METHOD = 'GET, POST, PUT, DELETE, OPTIONS, PATCH'.freeze
+        COMMON_HEADERS = 'Origin, Accept, Content-Type, X-Requested-With, Authorization, X-Frame-Options'.freeze
+        ONE_DAY = '1728000'.freeze
+
+        def allow_cors
+            headers[ALLOW_ORIGIN] = ANY_ORIGIN
+            headers[ALLOW_METHODS] = ANY_METHOD
+            headers[ALLOW_HEADERS] = COMMON_HEADERS
+            headers[MAX_AGE] = ONE_DAY
+        end
+        
+    
+        # Couchbase catch all
+        def entry_not_found(err)
+            logger.warn err.message
+            logger.warn err.backtrace.join("\n") if err.respond_to?(:backtrace) && err.backtrace
+            render nothing: true, status: :not_found  # 404
+        end
+
+        # Helper for extracting the id from the request
+        def id
+            return @id if @id
+            params.require(:id)
+            @id = params.permit(:id)[:id]
+        end
+
+        # Used to save and respond to all model requests
+        def save_and_respond(model)
+            yield if model.save && block_given?
+            respond_with :api, model
+        end
+    end
+end

data/app/controllers/orchestrator/persistence_controller.rb

@@ -0,0 +1,29 @@
+require 'spider-gazelle/upgrades/websocket'
+
+
+module Orchestrator
+    class PersistenceController < ApiController
+        CONTROL = Control.instance
+
+
+        # Supply a bearer_token param for oauth
+        def websocket
+            hijack = request.env['rack.hijack']
+            if hijack && CONTROL.ready
+                promise = hijack.call
+
+                # grab user for authorization checks in the web socket
+                user = current_user
+                promise.then do |hijacked|
+                    ws = ::SpiderGazelle::Websocket.new(hijacked.socket, hijacked.env)
+                    WebsocketManager.new(ws, user)
+                    ws.start
+                end
+
+                throw :async     # to prevent rails from complaining 
+            else
+                render nothing: true, status: :method_not_allowed
+            end
+        end
+    end
+end