cyclid 0.2.0

data/app/cyclid/monkey_patches.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# Add two methods to Hash
+class Hash
+  # http://chrisholtz.com/blog/lets-make-a-ruby-hash-map-method-that-returns-a-hash-instead-of-an-array/
+  def hmap
+    inject({}) do |hash, (k, v)|
+      hash.merge(yield(k, v))
+    end
+  end
+
+  # Interpolate the data in the ctx hash into any String values
+  def interpolate(ctx)
+    hmap do |key, value|
+      if value.is_a? String
+        { key => value % ctx }
+      else
+        { key => value }
+      end
+    end
+  end
+end
+
+# Add a method to Array
+class Array
+  # Interpolate the data in the ctx hash for each String & Hash item
+  def interpolate(ctx)
+    map do |entry|
+      if entry.is_a? Hash
+        entry.interpolate ctx
+      elsif entry.is_a? String
+        entry % @ctx
+      else
+        entry
+      end
+    end
+  end
+end

data/app/cyclid/plugin_registry.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+# Copyright 2016 Liqwyd Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Top level module for the core Cyclid code.
+module Cyclid
+  # Module for the Cyclid API
+  module API
+    # Module for Cyclid Plugins
+    module Plugins
+      # Intelligent system-wide registry of available plugins with helper
+      # methods to find them again
+      class Registry
+        def initialize
+          @plugins = []
+          @types = []
+        end
+
+        # Add a plugin to the registry
+        def register(plugin)
+          # XXX Perform sanity checks
+          @plugins << plugin
+
+          # Maintain a human<->type mapping
+          human_name = plugin.human_name
+          @types << { human: human_name, type: plugin.superclass }
+        end
+
+        # Find a plugin from the registry
+        def find(name, type)
+          object_type = nil
+
+          # Convert a human name to a type, if required
+          if type.is_a? String
+            @types.each do |registered_type|
+              next unless registered_type[:human] == type
+
+              object_type = registered_type[:type]
+              break
+            end
+          else
+            object_type = type
+          end
+
+          raise "couldn't map plugin type #{type}" if object_type.nil?
+
+          @plugins.each do |plugin|
+            return plugin if plugin.name == name && plugin.superclass == object_type
+          end
+          return nil
+        end
+
+        # Return a list of all plugins of a certain type
+        def all(type = nil)
+          list = []
+          @plugins.each do |plugin|
+            list << plugin if plugin.superclass == type or type.nil?
+          end
+          return list
+        end
+      end
+    end
+  end
+end

data/app/cyclid/plugins.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+# Copyright 2016 Liqwyd Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'require_all'
+require 'active_support/core_ext'
+
+require_relative 'health_helpers'
+
+# Top level module for the core Cyclid code.
+module Cyclid
+  # Module for the Cyclid API
+  module API
+    # Module for Cyclid Plugins
+    module Plugins
+      # Base class for Plugins
+      class Base
+        class << self
+          attr_reader :name
+
+          # Returns the 'human' name for the plugin type
+          def human_name
+            'base'
+          end
+
+          # Add the (derived) plugin to the plugin registry
+          def register_plugin(name)
+            @name = name
+            Cyclid.plugins.register(self)
+          end
+
+          # Get the configuration for the given org
+          def get_config(org)
+            # If the organization was passed by name, convert it into an Organization object
+            org = Organization.find_by(name: org) if org.is_a? String
+            raise 'organization does not exist' if org.nil?
+
+            # XXX Plugins of different types can have the same name; we need to
+            # add a 'type' field and also find by the type.
+            config = org.plugin_configs.find_by(plugin: @name)
+            if config.nil?
+              # No config currently exists; create a new default config
+              config = PluginConfig.new(plugin: @name,
+                                        version: '1.0.0',
+                                        config: Oj.dump(default_config.stringify_keys))
+              config.save!
+
+              org.plugin_configs << config
+            end
+
+            # Convert the model to a hash, add the config schema, and convert the JSON config
+            # blob back into a hash
+            config_hash = config.serializable_hash
+            config_hash['schema'] = config_schema
+            config_hash['config'] = Oj.load(config.config)
+
+            return config_hash
+          rescue StandardError => ex
+            Cyclid.logger.error "couldn't get/create plugin config for #{@name}: #{ex}"
+            raise
+          end
+
+          # Set the configuration for the given org
+          def set_config(new_config, org)
+            new_config.stringify_keys!
+
+            config = org.plugin_configs.find_by(plugin: @name)
+            if config.nil?
+              # No config currently exists; create a new default config
+              config = PluginConfig.new(plugin: @name,
+                                        version: '1.0.0',
+                                        config: Oj.dump(default_config.stringify_keys))
+              config.save!
+
+              org.plugin_configs << config
+            end
+
+            # Let the plugin validate & merge the changes into the config hash
+            config_hash = config.serializable_hash
+            current_config = config_hash['config']
+            Cyclid.logger.debug "current_config=#{current_config}"
+            merged_config = update_config(Oj.load(current_config), new_config)
+
+            raise 'plugin rejected the configuration' if merged_config == false
+
+            Cyclid.logger.debug "merged_config=#{merged_config}"
+
+            # Update the stored configuration
+            config.config = Oj.dump(merged_config.stringify_keys)
+            config.save!
+          end
+
+          # Validite the given configuration items and merge them into the correct configuration,
+          # returning an updated complete configuration that can be stored.
+          def update_config(_current, _new)
+            return false
+          end
+
+          # Provide the default configuration state that should be used when creating a new config
+          def default_config
+            {}
+          end
+
+          # Get the schema for the configuration data that the plugin stores
+          def config_schema
+            {}
+          end
+        end
+      end
+    end
+  end
+end
+
+require_rel 'plugins/*.rb'

data/app/cyclid/plugins/action.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+# Copyright 2016 Liqwyd Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Top level module for the core Cyclid code.
+module Cyclid
+  # Module for the Cyclid API
+  module API
+    # Module for Cyclid Plugins
+    module Plugins
+      # Base class for Action plugins
+      class Action < Base
+        def initialize(args = {})
+        end
+
+        # Return the 'human' name for the plugin type
+        def self.human_name
+          'action'
+        end
+
+        # Provide any additional run-time data, such as the transport &
+        # context, that the plugin will require for perform() but didn't get
+        # during initialize.
+        def prepare(args = {})
+          @transport = args[:transport]
+          @ctx = args[:ctx]
+        end
+
+        # Run the Action.
+        def perform(log)
+        end
+      end
+    end
+  end
+end
+
+require_rel 'action/*.rb'

data/app/cyclid/plugins/action/command.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+# Copyright 2016 Liqwyd Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Top level module for the core Cyclid code.
+module Cyclid
+  # Module for the Cyclid API
+  module API
+    # Module for Cyclid Plugins
+    module Plugins
+      # Command plugin
+      class Command < Action
+        Cyclid.logger.debug 'in the Command plugin'
+
+        def initialize(args = {})
+          args.symbolize_keys!
+
+          # At a bare minimum there has to be a command to execute.
+          raise 'a command action requires a command' unless args.include? :cmd
+
+          # The command & arguments can either be passed seperately, with the
+          # args as an array, or as a single string which we then split into
+          # a command & array of args.
+          if args.include? :args
+            @cmd = args[:cmd]
+            @args = args[:args]
+          else
+            cmd_args = args[:cmd].split
+            @cmd = cmd_args.shift
+            @args = cmd_args
+          end
+
+          Cyclid.logger.debug "cmd: '#{@cmd}' args: #{@args}"
+
+          @env = args[:env] if args.include? :env
+          @path = args[:path] if args.include? :path
+        end
+
+        # Note that we don't need to explicitly use the log for transport
+        # related tasks as the transport will take of writing any data from the
+        # commands into the log. The log is still passed in to perform() so that
+        # plugins can write their own data to it, as we do here by writing out
+        # the (optional) path & command that is being run.
+        def perform(log)
+          begin
+            # Export the environment data to the build host, if necesary
+            env = @env.interpolate(@ctx) if @env
+            @transport.export_env(env)
+
+            # Log the command being run (and the working directory, if one is
+            # set)
+            cmd_args = "#{@cmd} #{@args.join(' ')}"
+            log.write(@path.nil? ? "$ #{cmd_args}\n" : "$ #{@path} : #{cmd_args}\n")
+
+            # Interpolate any data from the job context
+            cmd_args = cmd_args % @ctx
+
+            # Interpolate the path if one is set
+            path = @path
+            path = path % @ctx unless path.nil?
+
+            # Run the command
+            success = @transport.exec(cmd_args, path)
+          rescue KeyError => ex
+            # Interpolation failed
+            log.write "#{ex.message}\n"
+            success = false
+          end
+
+          [success, @transport.exit_code]
+        end
+
+        # Register this plugin
+        register_plugin 'command'
+      end
+    end
+  end
+end

data/app/cyclid/plugins/action/email.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+# Copyright 2016 Liqwyd Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'mail'
+require 'erb'
+require 'premailer'
+
+# Top level module for the core Cyclid code.
+module Cyclid
+  # Module for the Cyclid API
+  module API
+    # Module for Cyclid Plugins
+    module Plugins
+      # Email notification plugin
+      class Email < Action
+        def initialize(args = {})
+          args.symbolize_keys!
+
+          raise 'an email action requires a message' unless args.include? :message
+          @message = args[:message]
+
+          raise 'an email action requires a recipient' unless args.include? :to
+          @to = args[:to]
+
+          @subject = args[:subject] || 'Cyclid notification'
+          @color = args[:color] || 'dodgerblue'
+        end
+
+        # Send an email to the configured recipient; the message is rendered
+        # into text & HTML via. an ERB template which inserts additional
+        # information from the context
+        def perform(log)
+          begin
+            # Retrieve the server-wide email configuration
+            config = Cyclid.config.plugins
+            email_config = load_email_config(config)
+
+            Cyclid.logger.debug "sending via. #{email_config[:server]}:#{email_config[:port]} " \
+                                "as #{email_config[:from]}"
+
+            # Add the job context
+            to = @to % @ctx
+            subject = @subject % @ctx
+            message = @message % @ctx
+
+            # Create a binding for the text & HTML ERB templates
+            info = { color: @color, title: subject }
+
+            bind = binding
+            bind.local_variable_set(:info, info)
+            bind.local_variable_set(:ctx, @ctx)
+            bind.local_variable_set(:message, message)
+
+            # Generate text email from a template
+            template_path = File.expand_path(File.join(__FILE__, '..', 'email', 'text.erb'))
+            template = ERB.new(File.read(template_path), nil, '%<>-')
+
+            text_body = template.result(bind)
+
+            # Generate the HTML email from a template
+            template_path = File.expand_path(File.join(__FILE__, '..', 'email', 'html.erb'))
+            template = ERB.new(File.read(template_path), nil, '%<>-')
+
+            html = template.result(bind)
+
+            # Run the HTML through Premailer to inline the styles
+            premailer = Premailer.new(html,
+                                      with_html_string: true,
+                                      warn_level: Premailer::Warnings::SAFE)
+            html_body = premailer.to_inline_css
+
+            # Create the email
+            mail = Mail.new
+            mail.from = email_config[:from]
+            mail.to = to
+            mail.subject = subject
+            mail.text_part do
+              body text_body
+            end
+            mail.html_part do
+              content_type 'text/html; charset=UTF8'
+              body html_body
+            end
+
+            # Deliver the email via. the configured server, using
+            # authentication if a username & password were provided.
+            log.write("sending email to #{@to}")
+
+            mail.delivery_method :smtp, address: email_config[:server],
+                                        port: email_config[:port],
+                                        user_name: email_config[:username],
+                                        password: email_config[:password]
+            mail.deliver
+
+            success = true
+          rescue StandardError => ex
+            log.write "#{ex.message}\n"
+            success = false
+          end
+
+          [success, 0]
+        end
+
+        # Register this plugin
+        register_plugin 'email'
+
+        private
+
+        # Load the config for the email plugin and set defaults if they're not
+        # in the config
+        def load_email_config(config)
+          config.symbolize_keys!
+
+          server_config = config[:email] || {}
+          Cyclid.logger.debug "config=#{server_config}"
+
+          server_config.symbolize_keys!
+
+          # Set defaults where no server configuration is set
+          server_config[:server] ||= 'localhost'
+          server_config[:port] ||= 587
+          server_config[:from] ||= 'cyclid@cyclid.io'
+
+          server_config[:username] ||= nil
+          server_config[:password] ||= nil
+
+          # Load any organization specific configuration
+          plugin_data = self.class.get_config(@ctx[:organization])
+          Cyclid.logger.debug "using plugin config #{plugin_data}"
+          plugin_config = plugin_data['config']
+
+          # Merge the plugin configuration onto the server configuration (I.e.
+          # plugin configuration over-rides server configuration) to produce
+          # the final configuration
+          email_config = {}
+          email_config[:server] = plugin_config[:server] || server_config[:server]
+          email_config[:port] = plugin_config[:port] || server_config[:port]
+          email_config[:from] = plugin_config[:from] || server_config[:from]
+
+          email_config[:username] = plugin_config[:username] || server_config[:username]
+          email_config[:password] = plugin_config[:password] || server_config[:password]
+
+          return email_config
+        end
+
+        # Static methods for handling plugin config data
+        class << self
+          # Update the plugin configuration
+          def update_config(current, new)
+            current.merge! new
+          end
+
+          # Default configuration for the email plugin
+          def default_config
+            config = {}
+            config['server'] = nil
+            config['port'] = nil
+            config['from'] = nil
+            config['username'] = nil
+            config['password'] = nil
+
+            return config
+          end
+
+          # Config schema for the email plugin
+          def config_schema
+            schema = []
+            schema << { name: 'server',
+                        type: 'string',
+                        description: 'SMTP server for outgoing emails',
+                        default: nil }
+            schema << { name: 'port',
+                        type: 'integer',
+                        description: 'SMTP server port to connect to',
+                        default: nil }
+            schema << { name: 'from',
+                        type: 'string',
+                        description: 'Sender email address',
+                        default: nil }
+            schema << { name: 'username',
+                        type: 'string',
+                        description: 'SMTP server username',
+                        default: nil }
+            schema << { name: 'password',
+                        type: 'string',
+                        description: 'SMTP server password',
+                        default: nil }
+
+            return schema
+          end
+        end
+      end
+    end
+  end
+end