whisk_deploy 0.6.26

data/lib/whiskey_disk/config.rb

@@ -0,0 +1,127 @@
+require 'yaml'
+require 'uri'
+require 'open-uri'
+require 'whiskey_disk/config/filter'
+
+class WhiskeyDisk
+  class Config
+    def fetch
+      raise "Cannot determine current environment -- try rake ... to=staging, for example." unless environment_name
+      filter_data(load_data)
+    end
+
+    def debug?
+      env_flag_is_true?('debug')
+    end
+    
+    def domain_limit
+      env_key_or_false?('only')
+    end
+    
+    def check_staleness?
+      env_flag_is_true?('check')
+    end
+    
+    def configuration_file
+      return path if valid_path?(path)
+      
+      files = []
+
+      files += [
+        File.join(base_path, 'deploy', specified_project_name, "#{environment_name}.yml"),  # /deploy/foo/staging.yml
+        File.join(base_path, 'deploy', "#{specified_project_name}.yml") # /deploy/foo.yml
+      ] if specified_project_name
+
+      files += [
+        File.join(base_path, 'deploy', "#{environment_name}.yml"),  # /deploy/staging.yml
+        File.join(base_path, "#{environment_name}.yml"), # /staging.yml
+        File.join(base_path, 'deploy.yml') # /deploy.yml
+      ]
+
+      files.each { |file|  return file if File.exists?(file) }
+
+      raise "Could not locate configuration file in path [#{base_path}]"
+    end
+
+    def environment_name
+      return false unless env_has_key?('to')
+      return ENV['to'] unless ENV['to'] =~ /:/
+      ENV['to'].split(/:/)[1]
+    end
+
+    def specified_project_name
+      return false unless env_has_key?('to')
+      return false unless ENV['to'] =~ /:/
+      ENV['to'].split(/:/).first
+    end
+    
+    def contains_rakefile?(path)
+      File.exists?(File.expand_path(File.join(path, 'Rakefile')))
+    end
+
+    def find_rakefile_from_current_path
+      original_path = Dir.pwd
+      while (!contains_rakefile?(Dir.pwd))
+        return File.join(original_path, 'config') if Dir.pwd == '/'
+        Dir.chdir('..')
+      end
+      File.join(Dir.pwd, 'config')
+    ensure
+      Dir.chdir(original_path)
+    end
+
+    def base_path
+      path || find_rakefile_from_current_path
+    end
+
+    def valid_path?(path)
+      return false unless path
+      uri = URI.parse(path)
+      return path if uri.scheme
+      return path if File.file?(path)
+    end
+
+    def project_name
+      specified_project_name || 'unnamed_project'
+    end
+
+    # called only by #load_data
+    def configuration_data
+      open(configuration_file) {|f| f.read }
+    end
+
+    # called only by #fetch
+    def load_data
+      YAML.load(configuration_data)
+    rescue Exception => e
+      raise %Q{Error reading configuration file [#{configuration_file}]: "#{e}"}
+    end
+    
+    def filter
+      @filter ||= WhiskeyDisk::Config::Filter.new(self)
+    end
+    
+    # called only by #fetch
+    def filter_data(data)
+      filter.filter_data(data)
+    end
+
+  private
+
+    def path
+      env_key_or_false?('path')
+    end
+
+    def env_has_key?(key)
+      ENV[key] && ENV[key] != ''
+    end
+
+    def env_flag_is_true?(key)
+      !!(env_has_key?(key) && ENV[key] =~ /^(?:t(?:rue)?|y(?:es)?|1)$/)
+    end
+
+    def env_key_or_false?(key)
+      env_has_key?(key) ? ENV[key] : false
+    end  
+  end
+end

data/lib/whiskey_disk/config/abstract_filter.rb

@@ -0,0 +1,19 @@
+class WhiskeyDisk
+  class Config
+    class AbstractFilter
+      attr_reader :config
+  
+      def initialize(config)
+        @config = config
+      end
+  
+      def project_name
+        config.project_name
+      end
+  
+      def environment_name
+        config.environment_name
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filter.rb

@@ -0,0 +1,48 @@
+require 'whiskey_disk/config/filters/stringify_hash_keys_filter'
+require 'whiskey_disk/config/filters/environment_scope_filter'
+require 'whiskey_disk/config/filters/project_scope_filter'
+require 'whiskey_disk/config/filters/select_project_and_environment_filter'
+require 'whiskey_disk/config/filters/add_environment_name_filter'
+require 'whiskey_disk/config/filters/add_project_name_filter'
+require 'whiskey_disk/config/filters/default_config_target_filter'
+require 'whiskey_disk/config/filters/default_domain_filter'
+require 'whiskey_disk/config/filters/hashify_domain_entries_filter'
+require 'whiskey_disk/config/filters/localize_domains_filter'
+require 'whiskey_disk/config/filters/check_for_duplicate_domains_filter'
+require 'whiskey_disk/config/filters/convert_role_strings_to_list_filter'
+require 'whiskey_disk/config/filters/drop_empty_domain_roles_filter'
+require 'whiskey_disk/config/filters/normalize_ssh_options_filter'
+
+class WhiskeyDisk
+  class Config
+    class Filter
+      attr_reader :config, :filters
+  
+      def initialize(config)
+        @config = config
+        @filters = [
+          StringifyHashKeysFilter,
+          EnvironmentScopeFilter,
+          ProjectScopeFilter,
+          SelectProjectAndEnvironmentFilter,
+          AddEnvironmentNameFilter,
+          AddProjectNameFilter,
+          DefaultConfigTargetFilter,
+          DefaultDomainFilter,
+          HashifyDomainEntriesFilter,
+          LocalizeDomainsFilter,
+          CheckForDuplicateDomainsFilter,
+          ConvertRoleStringsToListFilter,
+          DropEmptyDomainRolesFilter,
+          NormalizeSshOptionsFilter
+        ]
+      end
+  
+      def filter_data(data)
+        filters.inject(data.clone) do |result, filter|
+          result = filter.new(config).filter(result)
+        end
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/add_environment_name_filter.rb

@@ -0,0 +1,11 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class AddEnvironmentNameFilter < AbstractFilter
+      def filter(data)
+        data.merge( { 'environment' => environment_name } )
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/add_project_name_filter.rb

@@ -0,0 +1,11 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class AddProjectNameFilter < AbstractFilter
+      def filter(data)
+        data.merge( { 'project' => project_name } )
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/check_for_duplicate_domains_filter.rb

@@ -0,0 +1,21 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class CheckForDuplicateDomainsFilter < AbstractFilter
+      def check_domains(domain_list)
+        seen = {}
+        domain_list.each do |domain|
+          raise "duplicate domain [#{domain['name']}] in configuration file for project [#{environment_name}], target [#{environment_name}]" if seen[domain['name']]
+          seen[domain['name']] = true
+        end
+      end
+      
+      def filter(data)
+        check_domains(data['domain'])
+        data
+      end
+    end
+  end
+end
+

data/lib/whiskey_disk/config/filters/convert_role_strings_to_list_filter.rb

@@ -0,0 +1,20 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class ConvertRoleStringsToListFilter < AbstractFilter
+      def convert_roles_for_domain(domain)
+        return domain unless domain['roles']
+        domain.merge('roles' => [ domain['roles'] ].flatten)
+      end
+      
+      def convert_all_roles(domains_list)
+        domains_list.collect {|domain| convert_roles_for_domain(domain) }
+      end
+      
+      def filter(data)
+        data.merge('domain' => convert_all_roles(data['domain']))
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/default_config_target_filter.rb

@@ -0,0 +1,12 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class DefaultConfigTargetFilter < AbstractFilter
+      def filter(data)
+        return data if data['config_target']
+        data.merge( { 'config_target' => environment_name })
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/default_domain_filter.rb

@@ -0,0 +1,12 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class DefaultDomainFilter < AbstractFilter
+      def filter(data)
+        data.has_key?('domain') ? data : data.merge('domain' => [ { 'name' => 'local' } ] )
+      end
+    end
+  end
+end
+

data/lib/whiskey_disk/config/filters/drop_empty_domain_roles_filter.rb

@@ -0,0 +1,32 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class DropEmptyDomainRolesFilter < AbstractFilter
+      def has_empty_role?(domain)
+        return true unless domain.has_key?('roles')
+        return true if domain['roles'].nil?
+
+        roles = domain['roles'].uniq.compact
+        return true if roles == [ '' ]
+        return true if roles == []
+        
+        false
+      end
+      
+      def drop_empty_roles_for_domain(domain)
+        return domain unless has_empty_role?(domain)
+        domain.reject {|key, value| key == 'roles' }
+      end
+      
+      def drop_empty_domain_roles(domains_list)
+        domains_list.collect { |domain| drop_empty_roles_for_domain(domain) }
+      end
+      
+      def filter(data)
+        data.merge('domain' => drop_empty_domain_roles(data['domain']))
+      end
+    end
+  end
+end
+

data/lib/whiskey_disk/config/filters/environment_scope_filter.rb

@@ -0,0 +1,20 @@
+require 'whiskey_disk/config/abstract_filter'
+require 'whiskey_disk/config/filters/modules/scope_helper'
+
+class WhiskeyDisk
+  class Config
+    class EnvironmentScopeFilter < AbstractFilter      
+      include ScopeHelper
+
+      # is this data hash a bottom-level data hash without an environment name?
+      def needs_environment_scoping?(data)
+        repository_depth(data) == 0
+      end
+  
+      def filter(data)
+        return data unless needs_environment_scoping?(data)
+        { environment_name => data }
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/hashify_domain_entries_filter.rb

@@ -0,0 +1,29 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class HashifyDomainEntriesFilter < AbstractFilter
+      def needs_hashing?(domain)
+        ! domain.respond_to?(:keys)
+      end
+
+      def hashify_domain(domain)
+        needs_hashing?(domain) ? { 'name' => domain } : domain
+      end
+
+      def new_domain
+        { 'name' => '' }
+      end
+
+      def hashify_domains(domain_list)
+        return new_domain unless domain_list
+        [ domain_list ].flatten.collect {|domain| hashify_domain(domain) }
+      end
+
+      def filter(data)
+        data.merge('domain' => hashify_domains(data['domain']))
+      end
+    end
+  end
+end
+

data/lib/whiskey_disk/config/filters/localize_domains_filter.rb

@@ -0,0 +1,24 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class LocalizeDomainsFilter < AbstractFilter
+      def is_local?(name)
+        name.nil? or name == ''
+      end
+      
+      def localize(name)
+        is_local?(name) ? 'local' : name
+      end
+      
+      def localize_domains(domain_list)
+        domain_list.collect {|domain| domain.merge('name' => localize(domain['name'])) }
+      end
+
+      def filter(data)
+        data.merge('domain' => localize_domains(data['domain']))
+      end
+    end
+  end
+end
+

data/lib/whiskey_disk/config/filters/modules/scope_helper.rb

@@ -0,0 +1,11 @@
+class WhiskeyDisk
+  class Config
+    module ScopeHelper
+      def repository_depth(data, depth = 0)
+        raise 'no repository found' unless data.respond_to?(:has_key?)
+        return depth if data.has_key?('repository')
+        repository_depth(data.values.first, depth + 1)
+      end
+    end
+  end
+end

data/lib/whiskey_disk/config/filters/normalize_ssh_options_filter.rb

@@ -0,0 +1,29 @@
+require 'whiskey_disk/config/abstract_filter'
+
+class WhiskeyDisk
+  class Config
+    class NormalizeSshOptionsFilter < AbstractFilter
+      def drop_empties(options_list)
+        options_list.select {|option| option and option != '' }
+      end
+      
+      def drop_empty_ssh_options_for_domain(domain)
+        result = drop_empties([ domain['ssh_options'] ].flatten)
+        if result and result != []
+          domain.merge('ssh_options' => result)
+        else
+          domain.reject {|k,v| k == 'ssh_options' }
+        end
+      end
+      
+      def normalize_ssh_options(domains_list)
+        domains_list.collect { |domain| drop_empty_ssh_options_for_domain(domain) }
+      end
+      
+      def filter(data)
+        data.merge('domain' => normalize_ssh_options(data['domain']))
+      end
+    end
+  end
+end
+