fulmar 1.10.1 → 2.0.0

data/lib/fulmar/domain/service/config_test_service.rb

@@ -5,137 +5,55 @@ module Fulmar
     module Service
       # Tests the configuration
       class ConfigTestService
+        include Fulmar::Domain::Model
+
         def initialize(config)
           @config = config
-          @config.load_user_config = false
-          @config.reset
-        end
-
-        # Runs all methods beginning with test_ and returns the report
-        def run
-          @report = []
-          tests = methods.select { |name| name.to_s[0, 5] == 'test_' }
-          tests.each do |test|
-            send(test)
-          end
-          @report
-        end
-
-        def test_hostnames_exist
-          @config.each do |env, target, data|
-            if data[:hostname].blank? && !data[:host].blank?
-              @report << {
-                message: "#{env}:#{target} has a host (#{data[:host]}) but is missing a hostname",
-                severity: :warning
-              }
+          @tests = {}
+        end
+
+        def target_test(name, &block)
+          @tests[name] = Proc.new do
+            results = []
+            @config.each do |env, target, _data|
+              @config.set env, target
+              result = block.call(@config)
+              if result
+                result[:message] = "in [#{env}:#{target}]: #{result[:message]}"
+                results << result
+              end
             end
+            results.reject(&:nil?)
           end
-        end
 
-        def test_project_name_exists
-          if @config.project.name.blank?
-            add_report 'Project is missing a name', :warning
-          end
         end
 
-        def test_hostnames_in_ssh_config
-          hostnames = ssh_hostnames
-
-          @config.each do |env, target, data|
-            next if data[:hostname].blank?
-
-            unless hostnames.include? data[:hostname]
-              @report << {
-                message: "#{env}:#{target} has a hostname (#{data[:hostname]}) which is not found in your ssh config",
-                severity: :info
-              }
-            end
-          end
-        end
-
-        def test_required_hostnames
-          types = %i(rsync rsync_with_version maria)
-          @config.each do |env, target, data|
-            if types.include?(data[:type]) && data[:hostname].blank?
-              @report << {
-                message: "#{env}:#{target} requires a hostname (#{data[:hostname]})",
-                severity: :error
-              }
-            end
-          end
+        def global_test(name, &block)
+          @tests[name] = block
         end
 
-        def test_vhost_template_is_set
-          vhost_template = false
-
-          @config.each do |_env, _target, data|
-            vhost_template = true unless data[:vhost_template].blank?
-          end
-
-          add_report(
-            'The configuration uses the vhost feature but misses a valid configuration for it (missing :vhost_template)',
-            :warning
-          ) if @config.feature?(:vhost) && !vhost_template
-        end
-
-        # Run simple test which only require one configuration
-        def test_simple_tests
-          @config.each do |env, target, data|
-            tests = methods.select { |name| name.to_s[0, 12] == 'simple_test_' }
-            tests.each do |test|
-              send(test, env, target, data)
-            end
-          end
-        end
-
-        def simple_test_local_path_exists(env, target, data)
-          unless File.exist? data[:local_path]
-            add_report("#{env}:#{target} has no valid local_path (#{data[:local_path]})", :warning)
-          end
-        end
-
-        def simple_test_mariadb_feature_is_set(env, target, data)
-          if data[:type] == :maria && !@config.feature?(:database)
-            @report << {
-              message: "#{env}:#{target} uses mysql/mariadb but your config is missing the database feature",
-              severity: :notice
-            }
-          end
-        end
-
-        def simple_test_vhost_feature_is_set(env, target, data)
-          if data[:vhost_template] && !@config.feature?(:vhost)
-            @report << {
-              message: "#{env}:#{target} refers to a vhost_template but your config is missing the vhost feature",
-              severity: :warning
-            }
-          end
-        end
-
-        def simple_test_maria_db_config_exists(env, target, data)
-          if data[:type] == :maria && data[:maria][:database].blank?
-            add_report "#{env}:#{target} is missing a database name in maria:database", :error
+        # Runs all methods beginning with test_ and returns the report
+        def run
+          test_dirs = ["#{File.dirname(__FILE__)}/config_tests/"]
+          test_files = test_dirs.collect{ |dir| Dir.glob("#{dir}/*.rb") }.flatten
+          test_files.each do |file|
+            eval File.read(file)
           end
-        end
 
-        def simple_test_remote_path_exists_for_rsync(env, target, data)
-          types = [:rsync, :rsync_with_version]
-          if types.include?(data[:type]) && data[:remote_path].blank?
-            add_report "#{env}:#{target} is missing a remote path", :error
+          results = []
+          @tests.each_pair do |name, test|
+            results << test.call(@config)
           end
+          results.reject!(&:nil?)
+          results.reject!(&:empty?)
+          results.flatten!
+          results
         end
 
         protected
 
-        def add_report(message, severity)
-          @report << {
-            message: message,
-            severity: severity
-          }
-        end
-
         def ssh_hostnames
-          `grep -E '^Host [^ *]+$' ~/.ssh/config | sort | uniq | cut -d ' ' -f 2`.split("\n")
+          @ssh_hostnames ||= `grep -E '^Host [^ *]+$' ~/.ssh/config | sort | uniq | cut -d ' ' -f 2`.split("\n")
         end
       end
     end

data/lib/fulmar/domain/service/config_tests/hosts.rb

@@ -0,0 +1,23 @@
+target_test 'hostname is set' do |config|
+  if config[:hostname].blank? && !config[:host].blank?
+    next {
+      severity: :warning,
+      message: "config has a host (#{[:host]}) but is missing a hostname"
+    }
+  end
+end
+
+target_test 'hostnames in ssh config' do |config|
+  next if config[:hostname].blank?
+
+  unless ssh_hostnames.include? config[:hostname]
+    {severity: :info, message: "config has a hostname (#{config[:hostname]}) which is not in your ssh config"}
+  end
+end
+
+target_test 'required hostnames' do |config|
+  types = %i(rsync rsync_with_version maria)
+  if types.include?(config[:type]) && config[:hostname].blank?
+    next {severity: :error, message: "config requires a hostname (#{config[:hostname]})"}
+  end
+end

data/lib/fulmar/domain/service/config_tests/mariadb.rb

@@ -0,0 +1,19 @@
+# Move this file into the plugin
+
+target_test 'mariadb is loaded' do |config|
+  if config[:type] == :mariadb && !config.plugins.include?(:mariadb)
+    next {
+      severity: :warning,
+      message: 'config uses mysql/mariadb but your config is missing the maria plugin'
+    }
+  end
+end
+
+target_test 'database name exists' do |config|
+  if config.plugins.include?(:mariadb) && config[:maria] && config[:maria][:database].blank?
+    next {
+      severity: :error,
+      message: 'config is missing a database name in maria:database'
+    }
+  end
+end

data/lib/fulmar/domain/service/config_tests/paths.rb

@@ -0,0 +1,15 @@
+target_test 'local path exists' do |config|
+  if config[:local_path] && !File.exist?(config[:local_path])
+    next {
+      severity: :warning,
+      message: "local_path does not exist (#{config[:local_path]})"
+    }
+  end
+end
+
+target_test 'remote_path is set' do |config|
+  types = %w(rsync rsync_with_version)
+  if types.include?(config[:type]) && config[:remote_path].blank?
+    next {severity: :error, message: 'config is missing a remote path for rsync'}
+  end
+end

data/lib/fulmar/domain/service/config_tests/project.rb

@@ -0,0 +1,5 @@
+global_test 'project name is set' do |config|
+  next {severity: :warning,
+        message: 'Project name is not set (must be short, no spaces)'
+  } if config.project.name.blank?
+end

data/lib/fulmar/domain/service/configuration_service.rb

@@ -1,7 +1,8 @@
 require 'yaml'
 require 'pp'
 require 'fulmar/domain/model/project'
-require 'singleton'
+require 'fulmar/domain/model/configuration'
+require 'active_support/core_ext/hash/keys'
 
 module Fulmar
   module Domain
@@ -20,39 +21,17 @@ module Fulmar
           environments: {},
           features: {},
           hosts: {},
-          dependencies: { all: {} }
         }
 
-        include ::Singleton
+        include Singleton
 
         attr_reader :environment, :target
-        attr_accessor :load_user_config
+        attr_accessor :load_user_config, :debug
 
         def initialize
-          @environment = nil
-          @target = nil
           @load_user_config = true
         end
 
-        # Allow access of configuration via array/hash access methods (read access)
-        def [](id)
-          ready? ? configuration[:environments][@environment][@target][id] : nil
-        end
-
-        # Allow access of configuration via array/hash access methods (write access)
-        def []=(id, value)
-          if ready?
-            configuration[:environments][@environment][@target][id] = value
-          else
-            fail 'Environment or target not set. Please set both variables via configuration.environment = \'xxx\' / '\
-                 'configuration.target = \'yyy\''
-          end
-        end
-
-        def to_hash
-          ready? ? configuration[:environments][@environment][@target] : configuration
-        end
-
         def base_path
           @base_path ||= lookup_base_path
         end
@@ -61,68 +40,6 @@ module Fulmar
           @config ||= load_configuration
         end
 
-        def project
-          @project ||= Fulmar::Domain::Model::Project.new(configuration[:project])
-        end
-
-        def method_missing(name)
-          environment(name) if configuration[:environments][name]
-        end
-
-        def environment=(env)
-          @environment = env ? env.to_sym : nil
-        end
-
-        def target=(target)
-          @target = target ? target.to_sym : nil
-        end
-
-        def ssh_user_and_host
-          self[:user].blank? ? self[:hostname] : self[:user] + '@' + self[:hostname]
-        end
-
-        def dependencies(env = nil)
-          if env.nil? || !@config[:dependencies].has_key?(env)
-            @config[:dependencies][:all]
-          else
-            @config[:dependencies][:all].deep_merge(@config[:dependencies][env])
-          end
-        end
-
-        def ready?
-          return false if @environment.nil? || @target.nil?
-          fail 'Environment is invalid' if configuration[:environments][@environment].nil?
-          fail 'Target is invalid' if configuration[:environments][@environment][@target].nil?
-          true
-        end
-
-        def feature?(feature)
-          return configuration[:features].include? feature.to_s unless configuration[:features].nil?
-          case feature
-          when :database
-            any? { |data| data[:type] == 'maria' }
-          else
-            false
-          end
-        end
-
-        def each
-          configuration[:environments].each_key do |env|
-            configuration[:environments][env].each_pair do |target, data|
-              yield(env, target, data)
-            end
-          end
-        end
-
-        def any?
-          if block_given?
-            each { |_env, _target, data| return true if yield(data) }
-            false
-          else
-            configuration[:environments].any?
-          end
-        end
-
         # Merge another configuration into the currently active one
         # Useful for supplying a default configuration, as values are not overwritten.
         # Hashes are merged.
@@ -158,45 +75,17 @@ module Fulmar
           File.dirname(fulmar_file)
         end
 
-        # Fills a target with all globally set variables so all necessary information
-        # is found within each target
-        def fill_target(env, target)
-          @config[:environments][env][target] = @config[:environments][:all].deep_merge(@config[:environments][env][target]) if @config[:environments][:all]
-
-          return if @config[:environments][env][target][:host].blank?
-
-          host = @config[:environments][env][target][:host].to_sym
-          return unless @config[:hosts] && @config[:hosts][host]
-          @config[:hosts][host].each do
-            @config[:environments][env][target] = @config[:hosts][host].deep_merge(@config[:environments][env][target])
-          end
-        end
-
         # Loads the configuration from the YAML file and populates all targets
         def load_configuration
-          @config = BLANK_CONFIG
+          config = BLANK_CONFIG
           config_files.each do |config_file|
-            @config = @config.deep_merge((YAML.load_file(config_file) || {}).symbolize)
-          end
-
-          prepare_environments
-          prepare_dependencies
-          # Iterate over all environments and targets to prepare them
-          @config[:environments].delete(:all)
-          check_version
-          @config
-        end
-
-        def prepare_environments
-          @config[:environments].each_key do |env|
-            next if env == :all
-            @config[:environments][env].each_key do |target|
-              fill_target(env, target)
-              check_path(env, target)
-            end
+            config = config.deep_merge((YAML.load_file(config_file) || {}).deep_symbolize_keys)
           end
+          check_version(config[:project][:fulmar_version])
+          Fulmar::Domain::Model::Configuration.new(config, base_path, @debug)
         end
 
+        # @todo Move to configuration model if I know what this was or if it is relevant
         def prepare_dependencies
           @config[:dependencies].each_pair do |_env, repos|
             repos.each_pair do |_name, repo|
@@ -207,17 +96,10 @@ module Fulmar
           end
         end
 
-        def check_path(env, target)
-          path = @config[:environments][env][target][:local_path]
-          return if path.blank?
-          return if path[0,1] == '/'
-          @config[:environments][env][target][:local_path] = File.expand_path("#{base_path}/#{path}")
-        end
-
-        def check_version
-          return if @config[:project][:fulmar_version].nil?
-          unless  Gem::Dependency.new('', @config[:project][:fulmar_version]).match?('', Fulmar::VERSION)
-            fail "Project requires another version of fulmar: #{@config[:project][:fulmar_version]}"
+        def check_version(version)
+          return if version.nil?
+          unless  Gem::Dependency.new('', version).match?('', Fulmar::VERSION)
+            fail "Project requires a newer version of fulmar: #{version}"
           end
         end
       end

data/lib/fulmar/domain/service/file_sync_service.rb

@@ -1,19 +1,19 @@
 
-require 'fulmar/infrastructure/service/transfer/rsync'
-require 'fulmar/infrastructure/service/transfer/rsync_with_versions'
-require 'fulmar/infrastructure/service/transfer/tar'
+require 'fulmar/infrastructure/model/transfer/rsync'
+require 'fulmar/infrastructure/model/transfer/rsync_with_versions'
+require 'fulmar/infrastructure/model/transfer/tar'
 
 module Fulmar
   # Creates the required transfer model from the configuration
   class FileSync
-    def self.create_transfer(config)
+    def self.get_model(config)
       case config[:type]
       when 'rsync_with_versions'
-        transfer_model = Fulmar::Infrastructure::Service::Transfer::RsyncWithVersions.new(config)
+        transfer_model = Fulmar::Infrastructure::Model::Transfer::RsyncWithVersions.new(config)
       when 'rsync'
-        transfer_model = Fulmar::Infrastructure::Service::Transfer::Rsync.new(config)
+        transfer_model = Fulmar::Infrastructure::Model::Transfer::Rsync.new(config)
       when 'tar'
-        transfer_model = Fulmar::Infrastructure::Service::Transfer::Tar.new(config)
+        transfer_model = Fulmar::Infrastructure::Model::Transfer::Tar.new(config)
       else
         help = config[:type] == '' ? 'Add a "type: " field to your deployment yaml file. ' : ''
         transfer_model = nil

data/lib/fulmar/domain/service/helper/common_helper.rb

@@ -1,4 +1,5 @@
 require 'fulmar/domain/service/configuration_service'
+require 'fulmar/shell'
 require 'colorize'
 
 module Fulmar
@@ -9,73 +10,58 @@ module Fulmar
         module CommonHelper
           attr_accessor :environment
 
-          # @return [Hash]
-          def full_configuration
-            configuration.configuration
-          end
-
           # @return [Fulmar::Domain::Service::ConfigurationService]
-          def configuration
-            (@_config_service ||= Fulmar::Domain::Service::ConfigurationService.instance)
+          def config
+            (@_config_service ||= Fulmar::Domain::Service::ConfigurationService.instance.configuration)
           end
 
           # @return [Fulmar::Domain::Model::Project]
           def project
-            full_configuration[:project]
-          end
-
-          def composer(command, arguments = Fulmar::Infrastructure::Service::ComposerService::DEFAULT_PARAMS)
-            storage['composer'] ||= Fulmar::Infrastructure::Service::ComposerService.new(local_shell)
-            storage['composer'].shell.quiet = !configuration[:debug]
-            storage['composer'].execute(command, arguments)
+            config.project
           end
 
           # @return [Fulmar::Shell]
           def local_shell
-            storage['local_shell'] ||= new_shell(configuration[:local_path])
+            storage['local_shell'] ||= new_shell(config[:local_path])
           end
 
           # @return [Fulmar::Shell]
           def remote_shell
-            storage['remote_shell'] ||= new_shell(configuration[:remote_path], configuration.ssh_user_and_host)
+            storage['remote_shell'] ||= new_shell(config[:remote_path], config.ssh_user_and_host)
           end
 
           def file_sync
-            storage['file_sync'] ||= Fulmar::FileSync.create_transfer configuration
+            storage['file_sync'] ||= Fulmar::FileSync.get_model config
           end
 
           def render_templates
-            (Fulmar::Domain::Service::ConfigRenderingService.new configuration).render
-          end
-
-          def git
-            storage['git'] ||= Fulmar::Infrastructure::Service::GitService.new configuration
+            (Fulmar::Domain::Service::TemplateRenderingService.new config).render
           end
 
-          def upload(filename)
-            Fulmar::Infrastructure::Service::CopyService.upload(local_shell, filename, configuration.ssh_user_and_host, configuration[:remote_path])
+          def upload(filename, target = config[:remote_path])
+            Fulmar::Infrastructure::Service::CopyService.upload(local_shell, filename, config.ssh_user_and_host, target)
           end
 
-          def download(filename)
-            Fulmar::Infrastructure::Service::CopyService.download(local_shell, configuration.ssh_user_and_host, filename, configuration[:local_path])
+          def download(filename, target = config[:local_path])
+            Fulmar::Infrastructure::Service::CopyService.download(local_shell, config.ssh_user_and_host, filename, target)
           end
 
           def new_shell(path, hostname = 'localhost')
-            shell = Fulmar::Infrastructure::Service::ShellService.new(path, hostname)
+            shell = Fulmar::Shell.new(path, hostname)
             shell.strict = true
-            shell.debug = configuration[:debug]
+            shell.debug = config[:debug]
             shell
           end
 
           def ssh_config
-            storage['ssh_config'] ||= Fulmar::Infrastructure::Service::SSHConfigService.new configuration
+            storage['ssh_config'] ||= Fulmar::Infrastructure::Service::SSHConfigService.new config
           end
 
           def storage
-            fail 'You need to set an environment and a target first' unless configuration.ready?
+            fail 'You need to set an environment and a target first' unless config.ready?
             @storage ||= {}
-            @storage[configuration.environment] ||= {}
-            @storage[configuration.environment][configuration.target] ||= {}
+            @storage[config.environment] ||= {}
+            @storage[config.environment][config.target] ||= {}
           end
 
           def info(text)

data/lib/fulmar/domain/service/plugin_service.rb

@@ -0,0 +1,60 @@
+require 'singleton'
+require 'active_support/core_ext/string/inflections'
+require 'fulmar/domain/service/configuration_service'
+
+module Fulmar
+  module Domain
+    module Service
+      class PluginService
+        include Singleton
+
+        def self.instance
+          @@instance ||= new
+        end
+
+        def initialize
+          @plugins = {}
+          config = ConfigurationService.instance.configuration
+
+          if config.plugins.class == Array
+            fail 'Plugin list must not be an array. Have a look at https://github.com/CORE4/fulmar#plugins for ' +
+                   'more information'
+          end
+
+          config.plugins.each_pair do |name, plugin_config|
+            puts "Loading plugin '#{name}'..." if config.debug
+            require_plugin(name)
+            @plugins[name] = classname(name, :configuration).new(plugin_config)
+          end
+
+        end
+
+        def classname(plugin, name = nil)
+          "Fulmar::Plugin::#{class_map[plugin.to_s.downcase]}#{name.nil? ? '' : '::'+name.to_s.camelize}".constantize
+        end
+
+        def class_map
+          map = {}
+          Fulmar::Plugin.constants.each do |classname|
+            map[classname.to_s.downcase] = classname.to_s
+          end
+          map
+        end
+
+        def require_plugin(name)
+          require "fulmar/plugin/#{name}/configuration"
+        end
+
+        def helpers
+          @plugins.keys.select { |plugin| classname(plugin).constants.include? (:DslHelper) }.collect do |plugin|
+            classname(plugin, :DslHelper)
+          end
+        end
+
+        def rake_files
+          @plugins.values.collect(&:rake_files).flatten
+        end
+      end
+    end
+  end
+end

data/lib/fulmar/domain/service/{config_rendering_service.rb → template_rendering_service.rb}

@@ -4,14 +4,14 @@ module Fulmar
   module Domain
     module Service
       # Renders templates of config files
-      class ConfigRenderingService
+      class TemplateRenderingService
         def initialize(config)
           @config = config
         end
 
         def render
-          return unless @config[:config_templates]
-          @config[:config_templates].each do |template_file|
+          return unless @config[:templates]
+          @config[:templates].each do |template_file|
             template = template_path(template_file)
 
             renderer = ERB.new(File.read(template))

data/lib/fulmar/domain/task/configuration.rake

@@ -3,7 +3,7 @@ require 'pp'
 namespace :test do
   task :config do
     require 'fulmar/domain/service/config_test_service'
-    test_service = Fulmar::Domain::Service::ConfigTestService.new(configuration)
+    test_service = Fulmar::Domain::Service::ConfigTestService.new(config)
     results = test_service.run
 
     results.each do |report|
@@ -22,18 +22,20 @@ namespace :test do
 
   task :hosts do
     error_count = 0
-    configuration.each do |env, target, _data|
-      configuration.environment = env
-      configuration.target = target
+    config.each do |env, target, _data|
+      config.environment = env
+      config.target = target
 
-      next if configuration[:hostname].blank?
+      next if config[:hostname].blank?
       remote_shell.quiet = true
       remote_shell.strict = false
 
-      message = "Cannot open remote shell to host '#{configuration[:hostname]}' (#{env}:#{target})"
+      info "Testing #{env}:#{target}..."
+
+      message = "Cannot open remote shell to host '#{config[:hostname]}' (#{env}:#{target})"
 
       begin
-        remote_shell.run 'true' || error(message)
+        remote_shell.run('true') || error(message)
       rescue
         error(message)
       end