orchestrator 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 515ea3da1b17f0247c30e837c789ef827c9b5f47
-  data.tar.gz: b49edf4d8158eefbb656aad8400db3281f6f60ff
+  metadata.gz: 0ef8d250243fa583df69dd09efc6e68d126afa10
+  data.tar.gz: 4e2c7b6e3072bb9ba4568a80bc4382cdae5ac075
 SHA512:
-  metadata.gz: 93ff28f254174a0aa2867eaf230fc53865d47cab028927745def54ace1e40870067f6b94e9f9e4b4c730226225270c76275d54949e288d2904c551fbb42d8ef6
-  data.tar.gz: 91df975e0a46c5514fcc705e2c701fbf0d4ba9f9e084538b27531efd1a7b172cbed43b0c8f0c8fb6934f51fac38b44cfe00b314a7d320834543aba37686cf5e7
+  metadata.gz: 87a92954d832fab00b5668f536cd5a5d578df4a2cb3b7c9f7e6416734ff7888890adeb059a063980b3e67a02f1ea24fc5324dc8c910bfe3aabdf11bed09a0c82
+  data.tar.gz: 5022a425b4574947646acf024c04853a3482d7c8ff6ab6111c7bd0ede5229199cb806d95676ab44e3e0fc6942455591c61d872cb4dcbabdd7efbd2df35715932

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

@@ -3,7 +3,8 @@ module Orchestrator
     module Api
         class DependenciesController < ApiController
             respond_to :json
-            before_action :check_admin
+            before_action :check_admin, except: [:index, :show]
+            before_action :check_support, only: [:index, :show]
             before_action :find_dependency, only: [:show, :update, :destroy, :reload]
 
 

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

@@ -0,0 +1,37 @@
+
+module Orchestrator
+    module Api
+        class LogsController < ApiController
+            respond_to :json
+            before_action :doorkeeper_authorize!
+            before_action :check_admin
+
+
+            # deal with live reload   filter
+            @@elastic ||= Elastic.new(::Orchestrator::AccessLog)
+
+
+            def index
+                query = @@elastic.query(params)
+                query.sort = [{
+                    created_at: "desc"
+                }]
+
+                # Filter systems via user_id
+                if params.has_key? :user_id
+                    user_id = params.permit(:user_id)[:user_id]
+                    query.filter({
+                        user_id: [user_id]
+                    })
+                end
+
+                results = @@elastic.search(query) do |entry|
+                    entry.as_json.tap do |json|
+                        json[:systems] = ControlSystem.find_by_id(json[:systems]).as_json(only: [:id, :name]) || []
+                    end
+                end
+                respond_with results
+            end
+        end
+    end
+end

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

@@ -5,7 +5,7 @@ module Orchestrator
             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 :check_support, only: [:index, :exec]
             before_action :find_system,   only: [:show, :update, :destroy, :remove, :start, :stop]
 
 
@@ -122,8 +122,9 @@ module Orchestrator
                     index = para[:index]
                     mod = sys.get(para[:module].to_sym, index.nil? ? 0 : (index.to_i - 1))
                     if mod
+                        user = current_user
                         mod.thread.schedule do
-                            perform_exec(mod, para)
+                            perform_exec(mod, para, user)
                         end
                         throw :async
                     else
@@ -251,10 +252,10 @@ module Orchestrator
             end
 
             # Called on the module thread
-            def perform_exec(mod, para)
+            def perform_exec(mod, para, user)
                 defer = mod.thread.defer
 
-                req = Core::RequestProxy.new(mod.thread, mod)
+                req = Core::RequestProxy.new(mod.thread, mod, user)
                 args = para[:args] || []
                 result = req.send(para[:method].to_sym, *args)
 
@@ -268,6 +269,9 @@ module Orchestrator
                     defer.resolve(result)
                 end
 
+                respHeaders = {}
+                allow_cors(respHeaders)
+
                 defer.promise.then(proc { |res|
                     output = ''
                     begin
@@ -277,16 +281,14 @@ module Orchestrator
                         # 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]])
+                    respHeaders['Content-Length'] = output.bytesize
+                    respHeaders['Content-Type'] = 'application/json'
+                    env['async.callback'].call([200, respHeaders, [output]])
                 }, proc { |err|
                     output = err.message
-                    env['async.callback'].call([500, {
-                        'Content-Length' => output.bytesize,
-                        'Content-Type' => 'text/plain'
-                    }, [output]])
+                    respHeaders['Content-Length'] = output.bytesize
+                    respHeaders['Content-Type'] = 'text/plain'
+                    env['async.callback'].call([500, respHeaders, [output]])
                 })
             end
         end

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

@@ -0,0 +1,76 @@
+
+module Orchestrator
+    module Api
+        class UsersController < ApiController
+            respond_to :json
+            before_action :check_authorization, only: [:update]
+            before_action :check_admin, only: [:index, :destroy]
+
+
+            before_action :doorkeeper_authorize!
+
+
+            # deal with live reload   filter
+            @@elastic ||= Elastic.new(User)
+
+             # Admins can see a little more of the users data
+            ADMIN_DATA = User::PUBLIC_DATA.dup
+            ADMIN_DATA[:only] += [:support, :sys_admin, :email]
+
+
+            def index
+                query = @@elastic.query(params)
+                results = @@elastic.search(query) do |user|
+                    user.as_json(ADMIN_DATA)
+                end
+                respond_with results
+            end
+
+            def show
+                user = User.find(id)
+
+                # We only want to provide limited 'public' information
+                respond_with user, User::PUBLIC_DATA
+            end
+
+            def current
+                respond_with current_user
+            end
+
+
+            ##
+            # Requests requiring authorization have already loaded the model
+            def update
+                @user.update_attributes(safe_params)
+                @user.save
+                respond_with @user
+            end
+
+            # TODO:: We should only ever disable users... Need to add this flag
+            #def destroy
+            #    respond_with @user.delete
+            #end
+
+
+            protected
+
+
+            def safe_params
+                if current_user.sys_admin
+                    params.require(:user).permit(:name, :email, :nickname, :sys_admin, :support)
+                else
+                    params.require(:user).permit(:name, :email, :nickname)
+                end
+            end
+
+            def check_authorization
+                # Find will raise a 404 (not found) if there is an error
+                @user = User.find(id)
+                user = current_user
+
+                # Does the current user have permission to perform the current action
+                head(:forbidden) unless @user.id == user.id || user.sys_admin
+            end
+        end
+    end
+end

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

@@ -3,7 +3,8 @@ module Orchestrator
     module Api
         class ZonesController < ApiController
             respond_to :json
-            before_action :check_admin
+            before_action :check_admin, except: [:index, :show]
+            before_action :check_support, only: [:index, :show]
             before_action :find_zone, only: [:show, :update, :destroy]
 
 

data/app/controllers/orchestrator/api_controller.rb

@@ -1,6 +1,7 @@
 
 module Orchestrator
-    class ApiController < ::AcaEngineBase
+    class ApiController < ::Orchestrator::Base
+    	
 
         protected
 

data/app/controllers/orchestrator/base.rb

@@ -5,8 +5,8 @@ module Orchestrator
         rescue_from Couchbase::Error::NotFound, with: :entry_not_found
 
 
-        # Add headers to allow for CORS requests to the API
-        before_filter :allow_cors
+        before_action :doorkeeper_authorize!, except: :options
+        before_filter :allow_cors  # Add headers to allow for CORS requests to the API
 
 
         # This is a preflight OPTIONS request
@@ -28,11 +28,11 @@ module Orchestrator
         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
+        def allow_cors(headerHash = headers)
+            headerHash[ALLOW_ORIGIN] = ANY_ORIGIN
+            headerHash[ALLOW_METHODS] = ANY_METHOD
+            headerHash[ALLOW_HEADERS] = COMMON_HEADERS
+            headerHash[MAX_AGE] = ONE_DAY
         end
         
     
@@ -55,5 +55,22 @@ module Orchestrator
             yield if model.save && block_given?
             respond_with :api, model
         end
+
+        # Checking if the user is an administrator
+        def check_admin
+            user = current_user
+            head(:forbidden) unless user && user.sys_admin
+        end
+
+        # Checking if the user is support personnel
+        def check_support
+            user = current_user
+            head(:forbidden) unless user && (user.support || user.sys_admin)
+        end
+
+        # current user using doorkeeper
+        def current_user
+            @current_user ||= User.find(doorkeeper_token.resource_owner_id) if doorkeeper_token
+        end
     end
 end

data/app/models/orchestrator/access_log.rb

@@ -16,15 +16,21 @@ module Orchestrator
         attribute :notes
 
         attribute :created_at
-        attribute :ended_at,   default: lambda { Time.now.to_i }
+        attribute :ended_at
+        attribute :last_checked_at, default: 0
 
 
-        def initialize
-            super
-            self.created_at = Time.now.to_i
+        def initialize(*args)
+            super(*args)
+
+            if self.created_at.nil?
+                self.created_at = Time.now.to_i
+            end
         end
 
         def save
+            self.last_checked_at = Time.now.to_i
+
             if self.persisted
                 super
             else

data/app/models/orchestrator/edge_control.rb

@@ -0,0 +1,25 @@
+
+module Orchestrator
+    class EdgeControl < Couchbase::Model
+        design_document :edge
+        include ::CouchbaseId::Generator
+
+
+        attribute :name
+        attribute :description
+        attribute :failover
+        attribute :timeout,     default: 30
+        attribute :window_start   # CRON string
+        attribute :window_length  # Time in seconds
+        attribute :settings,    default: lambda { {} }
+        attribute :admins,      default: lambda { [] }
+        attribute :commit         # Current commit
+
+        attribute :created_at,  default: lambda { Time.now.to_i }
+
+
+        def online?(id)
+            
+        end
+    end
+end

data/app/models/user.rb

@@ -0,0 +1,8 @@
+
+class User < Couchbase::Model
+    # Mostly defined in coauth
+
+    # Protected attributes
+    attribute :sys_admin, default: false
+    attribute :support,   default: false
+end

data/config/routes.rb

@@ -33,6 +33,10 @@ Orchestrator::Engine.routes.draw do
         end
         resources :groups           # users define the groups they are in
         resources :zones            # zones define what groups can access them
+        resources :users do
+            get 'current',  on: :collection
+        end
+        resources :logs
         
         concerns  :mods
     end

data/lib/orchestrator/control.rb

@@ -30,6 +30,11 @@ module Orchestrator
             @exceptions = method(:log_unhandled_exception)
 
             @ready = false
+            @ready_defer = @loop.defer
+            @ready_promise = @ready_defer.promise
+
+            # We keep track of unloaded modules so we can optimise loading them again
+            @unloaded = Set.new
 
             if Rails.env.production?
                 logger = ::Logger.new(::Rails.root.join('log/control.log').to_s, 10, 4194304)
@@ -43,7 +48,7 @@ module Orchestrator
         end
 
 
-        attr_reader :logger, :loop, :ready, :zones
+        attr_reader :logger, :loop, :ready, :ready_promise, :zones, :threads
 
 
         # Start the control reactor
@@ -109,6 +114,19 @@ module Orchestrator
                         # update the module cache
                         defer.promise.then do |mod_manager|
                             @loaded[mod_id] = mod_manager
+
+                            # Transfer any existing observers over to the new thread
+                            if @ready && @unloaded.include?(mod_id)
+                                @unloaded.delete(mod_id)
+                                
+                                new_thread = thread.observer
+                                @threads.each do |thr|
+                                    thr.observer.move(mod_id, new_thread)
+                                end
+                            end
+
+                            # Return the manager
+                            mod_manager
                         end
                         defer.promise
                     }, @exceptions)
@@ -163,8 +181,10 @@ module Orchestrator
         # Stop the module gracefully
         # Then remove it from @loaded
         def unload(mod_id)
-            stop(mod_id).then(proc {
-                @loaded.delete(mod_id.to_sym)
+            mod = mod_id.to_sym
+            stop(mod).then(proc {
+                @unloaded << mod
+                @loaded.delete(mod)
                 true # promise response
             })
         end
@@ -196,6 +216,7 @@ module Orchestrator
             # Clear the system cache (in case it has been populated at all)
             System.clear_cache
             @ready = true
+            @ready_defer.resolve(true)
         end
 
         def log_unhandled_exception(*args)

data/lib/orchestrator/core/mixin.rb

@@ -75,8 +75,11 @@ module Orchestrator
             end
 
             def setting(name)
-                set = name.to_sym
-                @__config__.setting(set)
+                @__config__.setting(name.to_sym)
+            end
+
+            def thread
+                @__config__.thread
             end
 
             # Updates a setting that will effect the local module only
@@ -85,8 +88,7 @@ module Orchestrator
             # @param value [String|Symbol|Numeric|Array|Hash] the setting value
             # @return [::Libuv::Q::Promise] Promise that will resolve once the setting is persisted
             def define_setting(name, value)
-                set = name.to_sym
-                @__config__.define_setting(set, value)
+                @__config__.define_setting(name.to_sym, value)
             end
 
             def wake_device(mac, ip = '<broadcast>')
@@ -95,6 +97,10 @@ module Orchestrator
                 end
             end
 
+            def current_user
+                @__config__.current_user
+            end
+
             # Outputs any statistics collected on the module
             def __STATS__
                 stats = {}

data/lib/orchestrator/core/module_manager.rb

@@ -17,6 +17,7 @@ module Orchestrator
 
             attr_reader :thread, :settings, :instance
             attr_reader :status, :stattrak, :logger
+            attr_accessor :current_user
 
 
             # Should always be called on the module thread
@@ -83,9 +84,8 @@ module Orchestrator
             # NOTE:: Couchbase does support non-blocking gets although I think this is simpler
             #
             # @return [::Orchestrator::Core::SystemProxy]
-            # @raise [Couchbase::Error::NotFound] if unable to find the system in the DB
             def get_system(name)
-                id = ::Orchestrator::ControlSystem.bucket.get("sysname-#{name}")
+                id = ::Orchestrator::ControlSystem.bucket.get("sysname-#{name.downcase}", {quiet: true}) || name
                 ::Orchestrator::Core::SystemProxy.new(@thread, id.to_sym, self)
             end
 
@@ -144,7 +144,7 @@ module Orchestrator
             def setting(name)
                 res = @settings.settings[name]
                 if res.nil?
-                    if !@settings.control_system_id.nil?
+                    if @settings.control_system_id
                         sys = System.get(@settings.control_system_id)
                         res = sys.settings[name]