orchestrator 1.0.1

data/app/models/orchestrator/access_log.rb

@@ -0,0 +1,35 @@
+
+module Orchestrator
+    class AccessLog < Couchbase::Model
+        design_document :alog
+        include ::CouchbaseId::Generator
+
+
+        TTL = Rails.env.production? ? 2.weeks.to_i : 120
+
+
+        belongs_to :user,      class_name: "::User"
+        attribute  :systems,   default: lambda { [] }
+
+        attribute :persisted,  default: false
+        attribute :suspected,  default: false
+        attribute :notes
+
+        attribute :created_at
+        attribute :ended_at,   default: lambda { Time.now.to_i }
+
+
+        def initialize
+            super
+            self.created_at = Time.now.to_i
+        end
+
+        def save
+            if self.persisted
+                super
+            else
+                super(ttl: TTL)
+            end
+        end
+    end
+end

data/app/models/orchestrator/control_system.rb

@@ -0,0 +1,160 @@
+require 'set'
+require 'addressable/uri'
+
+
+module Orchestrator
+    class ControlSystem < Couchbase::Model
+        design_document :sys
+        include ::CouchbaseId::Generator
+        
+        # Allows us to lookup systems by names
+        before_save     :update_name
+        after_save      :expire_cache
+
+        before_delete   :cleanup_modules
+        after_delete    :expire_cache
+
+
+        attribute :name
+        define_attribute_methods :name  # dirty attributes for name!
+
+        attribute :description
+
+        attribute :zones,       default: lambda { [] }
+        attribute :modules,     default: lambda { [] }
+        attribute :settings,    default: lambda { {} }
+
+        attribute :created_at,  default: lambda { Time.now.to_i }
+
+        # Provide a field for simplifying support
+        attribute :support_url
+
+
+        def self.find_by_name(name)
+            id = ControlSystem.bucket.get("sysname-#{self.name.downcase}", {quiet: true})
+            ControlSystem.find_by_id(id) if id
+        end
+
+
+        def name=(new_name)
+            new_name.strip!
+            write_attribute(:name, new_name)
+        end
+
+        def expire_cache(noUpdate = nil)
+            ::Orchestrator::System.expire(self.id || @old_id)
+            ctrl = ::Orchestrator::Control.instance
+
+            # If not deleted and control is running
+            # then we want to trigger updates on the logic modules
+            if !@old_id && noUpdate.nil? && ctrl.ready
+                (::Orchestrator::Module.find_by_id(self.modules) || []).each do |mod|
+                    if mod.control_system_id
+                        manager = ctrl.loaded? mod.id
+                        manager.reloaded(mod) if manager
+                    end
+                end
+            end
+        end
+
+
+        def self.using_module(mod_id)
+            by_modules({key: mod_id, stale: false})
+        end
+        view :by_modules
+
+        def self.in_zone(zone_id)
+            by_zones({key: zone_id, stale: false})
+        end
+        view :by_zones
+
+
+        # Methods for obtaining the modules and zones as objects
+        def module_data
+            (::Orchestrator::Module.find_by_id(modules) || []).collect do |mod| 
+                mod.as_json({
+                    include: {
+                        dependency: {
+                            only: [:name, :module_name]
+                        }
+                    }
+                })
+            end
+        end
+
+        def zone_data
+            ::Orchestrator::Zone.find_by_id(zones) || []
+        end
+
+
+        protected
+
+
+        # Zones and settings are only required for confident coding
+        validates :name,        presence: true
+        validates :zones,       presence: true
+
+        validate  :support_link
+
+        def support_link
+            if self.support_url.nil? || self.support_url.empty?
+                self.support_url = nil
+            else
+                begin
+                    url = Addressable::URI.parse(self.support_url)
+                    url.scheme && url.host && url
+                rescue
+                    errors.add(:support_url, 'is an invalid URI')
+                end
+            end
+        end
+
+        validate  :name_unique
+
+        def name_unique
+            return false if self.name.blank?
+
+            result = ControlSystem.bucket.get("sysname-#{name.downcase}", {quiet: true})
+            if result != nil && result != self.id
+                errors.add(:name, 'has already been taken')
+            end
+        end
+
+        def update_name
+            if self.name_changed?
+                old_name = self.name_was
+                old_name.downcase! if old_name
+            elsif not self.exists?
+                old_name = false
+            else
+                return
+            end
+
+            current_name = self.name.downcase
+
+            if old_name != current_name
+                bucket = ControlSystem.bucket
+                bucket.delete("sysname-#{old_name}", {quiet: true}) if old_name
+                bucket.set("sysname-#{current_name}", self.id)
+            end
+        end
+
+        # 1. Find systems that have each of the modules specified
+        # 2. If this is the last system we remove the modules
+        def cleanup_modules
+            ControlSystem.bucket.delete("sysname-#{self.name.downcase}", {quiet: true})
+
+            self.modules.each do |mod_id|
+                systems = ControlSystem.using_module(mod_id).fetch_all
+
+                if systems.length <= 1
+                    # We don't use the model's delete method as it looks up control systems
+                    ::Orchestrator::Control.instance.unload(mod_id)
+                    ::Orchestrator::Module.bucket.delete(mod_id, {quiet: true})
+                end
+            end
+            
+            @old_id = self.id # not sure if required
+        end
+    end
+end

data/app/models/orchestrator/dependency.rb

@@ -0,0 +1,87 @@
+require 'set'
+
+
+module Orchestrator
+    class Dependency < Couchbase::Model
+        design_document :dep
+        include ::CouchbaseId::Generator
+
+
+        after_save    :update_modules
+        before_delete :cleanup_modules
+
+
+        ROLES = Set.new([:device, :service, :logic])
+
+
+        attribute :name
+        attribute :role
+        attribute :description
+        attribute :default # default data (port or URI)
+
+        # Override default role accessors
+        def role
+            @role ||= self.attributes[:role].to_sym if self.attributes[:role]
+        end
+        def role=(name)
+            @role = name.to_sym
+            self.attributes[:role] = name
+        end
+
+        attribute :class_name
+        attribute :module_name
+        attribute :settings,        default: lambda { {} }
+
+        attribute :created_at,      default: lambda { Time.now.to_i }
+
+
+        # Find the modules that rely on this dependency
+        def modules
+            ::Orchestrator::Module.dependent_on(self.id)
+        end
+
+        def default_port=(port)
+            self.role = :device
+            self.default = port
+        end
+
+        def default_uri=(uri)
+            self.role = :service
+            self.default = uri
+        end
+
+
+        protected
+
+
+        # Validations
+        validates :name,            presence: true
+        validates :class_name,      presence: true
+        validates :module_name,     presence: true
+        validate  :role_exists
+
+
+        def role_exists
+            if self.role && ROLES.include?(self.role.to_sym)
+                self.role = self.role.to_s
+            else
+                errors.add(:role, 'is not valid')
+            end
+        end
+
+        # Delete all the module references relying on this dependency
+        def cleanup_modules
+            modules.each do |mod|
+                mod.delete
+            end
+        end
+
+        # Reload all modules to update their settings
+        def update_modules
+            modules.each do |mod|
+                manager = ctrl.loaded? mod.id
+                manager.reloaded(mod) if manager
+            end
+        end
+    end
+end

data/app/models/orchestrator/mod/by_dependency/map.js

@@ -0,0 +1,6 @@
+
+function(doc) {
+    if(doc.type == "mod" && doc.dependency_id != null) {
+        emit(doc.dependency_id, null);
+    }
+}

data/app/models/orchestrator/mod/by_module_type/map.js

@@ -0,0 +1,6 @@
+
+function(doc) {
+    if(doc.type === "mod") {
+        emit(doc.role, null);
+    }
+}

data/app/models/orchestrator/module.rb

@@ -0,0 +1,127 @@
+require 'addressable/uri'
+
+
+module Orchestrator
+    class Module < Couchbase::Model
+        design_document :mod
+        include ::CouchbaseId::Generator
+
+
+        # The classes / files that this module requires to execute
+        # Defines module type
+        # Requires dependency_id to be set
+        belongs_to :dependency, :class_name => "Orchestrator::Dependency"
+        belongs_to :control_system, :class_name => "Orchestrator::ControlSystem"
+
+
+        # Device module
+        def hostname; ip; end
+        def hostname=(host); ip = host; end
+        attribute :ip
+        attribute :tls
+        attribute :udp
+        attribute :port
+        attribute :makebreak,   default: false
+
+        # HTTP Service module
+        attribute :uri
+
+        # Custom module names (in addition to what is defined in the dependency)
+        attribute :custom_name
+        attribute :settings,    default: lambda { {} }
+
+        attribute :created_at,  default: lambda { Time.now.to_i }
+        attribute :role         # cache the dependency role locally for load order
+
+        # Connected state in model so we can filter and search on it
+        attribute :connected,   default: true
+        attribute :running,     default: false
+        attribute :notes
+
+
+        # helper method for looking up the manager
+        def manager
+            ::Orchestrator::Control.instance.loaded? self.id
+        end
+
+
+        # Loads all the modules for this node
+        def self.all
+            # ascending order by default (device, service then logic)
+            by_module_type(stale: false)
+        end
+        view :by_module_type
+
+        # Finds all the modules belonging to a particular dependency
+        def self.dependent_on(dep_id)
+            by_dependency({key: dep_id, stale: false})
+        end
+        view :by_dependency
+
+
+        protected
+
+
+        validates :dependency, presence: true
+        validate  :configuration
+
+        def configuration
+            return unless dependency
+            case dependency.role
+            when :device
+                self.role = 1
+                self.port = (self.port || dependency.default).to_i
+
+                errors.add(:ip, 'cannot be blank') if self.ip.blank?
+                errors.add(:port, 'is invalid') unless self.port.between?(1, 65535)
+
+                # Ensure tls and upd values are correct
+                # can't have udp + tls
+                self.udp = !!self.udp
+                if self.udp
+                    self.tls = false
+                else
+                    self.tls = !!self.tls
+                end
+
+                begin
+                    url = Addressable::URI.parse("http://#{self.ip}:#{self.port}/")
+                    url.scheme && url.host && url
+                rescue
+                    errors.add(:ip, 'address / hostname or port are not valid')
+                end
+            when :service
+                self.role = 2
+
+                self.tls = nil
+                self.udp = nil
+
+                begin
+                    self.uri ||= dependency.default
+                    url = Addressable::URI.parse(self.uri)
+                    url.scheme && url.host && url
+                rescue
+                    errors.add(:uri, 'is an invalid URI')
+                end
+            else # logic
+                self.connected = true  # it is connectionless
+                self.tls = nil
+                self.udp = nil
+                self.role = 3
+                if control_system.nil?
+                    errors.add(:control_system, 'must be associated')
+                end
+            end
+        end
+
+        before_delete :unload_module
+        def unload_module
+            ::Orchestrator::Control.instance.unload(self.id)
+            # Find all the systems with this module ID and remove it
+            ControlSystem.using_module(self.id).each do |cs|
+                cs.modules.delete(self.id)
+                cs.save
+            end
+        end
+    end
+end

data/app/models/orchestrator/sys/by_modules/map.js

@@ -0,0 +1,9 @@
+
+function(doc) {
+    if(doc.type == "sys") {
+        var i;
+        for (i = 0; i < doc.modules.length; i++) {
+            emit(doc.modules[i], null);
+        }
+    }
+}

data/app/models/orchestrator/sys/by_zones/map.js

@@ -0,0 +1,9 @@
+
+function(doc) {
+    if(doc.type == "sys") {
+        var i;
+        for (i = 0; i < doc.zones.length; i++) {
+            emit(doc.zones[i], null);
+        }
+    }
+}