r10k 0.0.9 → 1.0.0rc1

data/lib/r10k/cli/synchronize.rb

@@ -1,8 +1,5 @@
-require 'r10k/cli'
-require 'r10k/deployment'
-require 'r10k/action/environment'
+require 'r10k/cli/deploy'
 
-require 'middleware'
 require 'cri'
 
 module R10K::CLI
@@ -11,30 +8,17 @@ module R10K::CLI
       @cmd ||= Cri::Command.define do
         name  'synchronize'
         usage 'synchronize <options>'
-        summary 'Fully synchronize all environments'
+        summary 'DEPRECATED: Fully synchronize all environments'
 
-        run do |opts, args, cmd|
-          deployment   = R10K::Deployment.instance
-          environments = deployment.environments
-          directories  = (deployment.config[:purgedirs] || [])
-
-          stack = Middleware::Builder.new do
-            environments.each do |env|
-              use R10K::Action::Environment::Deploy, env
-            end
+        required :c, :config, 'Specify a configuration file'
 
-            directories.each do |dir|
-              use R10K::Action::Environment::Purge, dir
-            end
-          end
+        be_hidden
 
-          stack_env = {
-            :update_cache => true,
-            :trace        => opts[:trace],
-            :recurse      => true,
-          }
+        run do |opts, args, cmd|
+          logger.warn "#{cmd.name} is deprecated; please use `r10k deploy environment --puppetfile`"
 
-          stack.call(stack_env)
+          opts.merge!({:puppetfile => true})
+          R10K::CLI::Deploy::Environment.command.block.call(opts,args,cmd)
         end
       end
     end

data/lib/r10k/cli/version.rb

@@ -0,0 +1,22 @@
+require 'r10k/cli'
+require 'r10k/version'
+
+require 'cri'
+
+module R10K::CLI
+  module Version
+    def self.command
+      @cmd ||= Cri::Command.define do
+        name    'version'
+        usage   'version'
+        summary 'Print the version of r10k'
+
+        run do |opts, args, cmd|
+          puts R10K::VERSION
+          exit 0
+        end
+      end
+    end
+  end
+  self.command.add_command(Version.command)
+end

data/lib/r10k/deployment.rb

@@ -1,45 +1,74 @@
 require 'r10k'
-require 'r10k/config'
-require 'r10k/synchro/git'
+require 'r10k/deployment/source'
+require 'r10k/deployment/config'
+
 require 'yaml'
 
-class R10K::Deployment
+module R10K
+class Deployment
   # Model a full installation of module directories and modules.
 
-  class << self
-    def instance
-      @myself ||= self.new
-    end
+  # Generate a deployment object based on a config
+  #
+  # @param path [String] The path to the deployment config
+  # @return [R10K::Deployment] The deployment loaded with the given config
+  def self.load_config(path)
+    config = R10K::Deployment::Config.new(path)
+    new(config)
+  end
 
-    def config
-      instance.config
-    end
+  def initialize(config)
+    @config = config
 
-    def collection
-      instance.collection
-    end
+    load_environments
   end
 
-  def initialize
-    @config = R10K::Config.new
+  def fetch_sources
+    sources.each do |source|
+      source.fetch_remote
+    end
+    load_environments
   end
 
-  def config
-    @config
+  # Lazily load all sources
+  #
+  # This instantiates the @_sources instance variable, but should not be
+  # used directly as it could be legitimately unset if we're doing lazy
+  # loading.
+  #
+  # @return [Array<R10K::Deployment::Source>] All repository sources
+  #   specified in the config
+  def sources
+    load_sources if @_sources.nil?
+    @_sources
   end
 
-  # Load up all module roots
+  # Lazily load all environments
   #
-  # @return [Array<R10K::Root>]
+  # This instantiates the @_environments instance variable, but should not be
+  # used directly as it could be legitimately unset if we're doing lazy
+  # loading.
+  #
+  # @return [Array<R10K::Deployment::Environment>] All enviroments across
+  #   all sources
   def environments
-    collection.to_a
+    load_environments if @_environments.nil?
+    @_environments
   end
 
-  def collection
-    @config.load_config unless @config.loaded?
-    @collection ||= R10K::Deployment::EnvironmentCollection.new(@config)
-    @collection
+  private
+
+  def load_sources
+    @_sources = @config.setting(:sources).map do |(name, hash)|
+      R10K::Deployment::Source.vivify(name, hash)
+    end
   end
-end
 
-require 'r10k/deployment/environment_collection'
+  def load_environments
+    @_environments = []
+    sources.each do |source|
+      @_environments += source.environments
+    end
+  end
+end
+end

data/lib/r10k/deployment/config.rb

@@ -0,0 +1,69 @@
+require 'r10k/deployment'
+require 'r10k/deployment/config/loader'
+
+module R10K
+class Deployment
+class Config
+
+  attr_accessor :configfile
+
+  def initialize(configfile)
+    @configfile = configfile
+
+    load_config
+  end
+
+  # Perform a scan for key and check for both string and symbol keys
+  def setting(key)
+    keys = [key]
+    case key
+    when String
+      keys << key.to_sym
+    when Symbol
+      keys << key.to_s
+    end
+
+    # Scan all possible keys to see if the config has a matching value
+    keys.inject(nil) do |rv, k|
+      require 'pry'; binding.pry
+      v = @config[k]
+      break v unless v.nil?
+    end
+  end
+
+  # Load and store a config file, and set relevant options
+  #
+  # @param [String] configfile The path to the YAML config file
+  def load_config
+    if @configfile.nil?
+      loader = R10K::Deployment::Config::Loader.new
+      @configfile = loader.search
+      if @configfile.nil?
+        raise ConfigError, "No configuration file given, no config file found in parent directory, and no global config present"
+      end
+    end
+    begin
+      @config = YAML.load_file(@configfile)
+      apply_config_settings
+    rescue => e
+      raise ConfigError, "Couldn't load config file: #{e.message}"
+    end
+  end
+
+  private
+
+  # Apply config settings to the relevant classes after a config has been loaded.
+  #
+  # @note this is hack. And gross. And terribad. I am sorry.
+  def apply_config_settings
+    cachedir = setting(:cachedir)
+    if cachedir
+      R10K::Git::Cache.cache_root = cachedir
+    end
+  end
+
+  class ConfigError < StandardError
+  end
+end
+end
+end

data/lib/r10k/{config → deployment/config}/loader.rb

@@ -1,9 +1,10 @@
-require 'r10k'
 
-class R10K::Config
-end
-
-class R10K::Config::Loader
+module R10K
+class Deployment
+class Config
+class Loader
+  # Search for a deployment configuration file (r10k.yaml) in all parent
+  # directories and in /etc/r10k.yaml
 
   def initialize
     @loadpath = []
@@ -37,3 +38,6 @@ class R10K::Config::Loader
     @loadpath
   end
 end
+end
+end
+end

data/lib/r10k/deployment/environment.rb

@@ -0,0 +1,88 @@
+require 'r10k/module'
+require 'r10k/logging'
+
+module R10K
+class Deployment
+class Environment
+
+  include R10K::Logging
+
+  # @!attribute [r] ref
+  #   The git ref to instantiate into the basedir
+  attr_reader :ref
+
+  # @!attribute [r] remote
+  #   The location of the remote git repository
+  attr_reader :remote
+
+  # @!attribute [r] basedir
+  #   The basedir to clone the root into
+  attr_reader :basedir
+
+  # @!attribute [r] dirname
+  #   @return [String] The directory name to use for the environment
+  attr_reader :dirname
+
+  # @param [String] ref
+  # @param [String] remote
+  # @param [String] basedir
+  # @param [String] dirname The directory to clone the root into, defaults to ref
+  def initialize(ref, remote, basedir, dirname = nil)
+    @ref     = ref
+    @remote  = remote
+    @basedir = basedir
+    @dirname = sanitize_dirname(dirname || ref)
+
+    @working_dir = R10K::Git::WorkingDir.new(@ref, @remote, @basedir, @dirname)
+
+    @full_path = File.join(@basedir, @dirname)
+  end
+
+  def sync
+    recursive_needed = !(@working_dir.cloned?)
+    @working_dir.sync
+
+    if recursive_needed
+      logger.debug "Environment #{@full_path} is a fresh clone; automatically updating modules."
+      sync_modules
+    end
+  end
+
+  def sync_modules
+    modules.each do |mod|
+      mod.sync
+    end
+  end
+
+  def puppetfile
+    @puppetfile ||= R10K::Puppetfile.new(@full_path)
+  end
+
+  def modules
+    puppetfile.load
+    puppetfile.modules
+  end
+
+  private
+
+  # Strip out non-word characters in an environment directory name
+  #
+  # Puppet can only use word characers (letter, digit, underscore) in
+  # environment names; this cleans up environment names to avoid traversals
+  # and similar issues.
+  #
+  # @param input [String] The raw branch name
+  #
+  # @return [String] The sanitized branch dirname
+  def sanitize_dirname(input)
+    output  = input.dup
+    invalid = %r[\W+]
+    if output.gsub!(invalid, '_')
+      logger.warn "Environment #{input.inspect} contained non-word characters; sanitizing to #{output.inspect}"
+    end
+
+    output
+  end
+end
+end
+end

data/lib/r10k/deployment/source.rb

@@ -0,0 +1,79 @@
+require 'r10k/git/cache'
+require 'r10k/deployment/environment'
+require 'r10k/util/purgeable'
+
+module R10K
+class Deployment
+class Source
+  # Represents a git repository to map branches to environments
+  #
+  # This module is backed with a bare git cache that's used to enumerate
+  # branches. The cache isn't used for anything else here, but all environments
+  # using that remote will be able to reuse the cache.
+
+  # @!attribute [r] name
+  #   @return [String] The short name for the deployment source
+  attr_reader :name
+
+  # @!attribute [r] source
+  #   @return [String] The git remote to use for environments
+  attr_reader :remote
+
+  # @!attribute [r] basedir
+  #   @return [String] The base directory to deploy the environments into
+  attr_reader :basedir
+
+  # @!attribute [r] environments
+  #   @return [Array<R10K::Deployment::Environment>] All environments for this source
+  attr_reader :environments
+
+  def self.vivify(name, attrs)
+    remote  = (attrs.delete(:remote) || attrs.delete('remote'))
+    basedir = (attrs.delete(:basedir) || attrs.delete('basedir'))
+
+    raise ArgumentError, "Unrecognized attributes for #{self.name}: #{attrs.inspect}" unless attrs.empty?
+    new(name, remote, basedir)
+  end
+
+  def initialize(name, remote, basedir)
+    @name    = name
+    @remote  = remote
+    @basedir = basedir
+
+    @cache   = R10K::Git::Cache.new(@remote)
+
+    load_environments
+  end
+
+  def fetch_remote
+    @cache.sync
+    load_environments
+  end
+
+  include R10K::Util::Purgeable
+
+  def managed_directory
+    @basedir
+  end
+
+  # List all environments that should exist in the basedir for this source
+  # @note This implements a required method for the Purgeable mixin
+  # @return [Array<String>]
+  def desired_contents
+    @environments.map {|env| env.dirname }
+  end
+
+  private
+
+  def load_environments
+    if @cache.cached?
+      @environments = @cache.branches.map do |branch|
+        R10K::Deployment::Environment.new(branch, @remote, @basedir)
+      end
+    else
+      @environments = []
+    end
+  end
+end
+end
+end

data/lib/r10k/errors.rb

@@ -1,7 +1,5 @@
-require 'r10k'
-
 module R10K
-  class ExecutionFailure < Exception
-    attr_accessor :exit_code, :stdout, :stderr
-  end
+class ExecutionFailure < StandardError
+  attr_accessor :exit_code, :stdout, :stderr
+end
 end