r10k 0.0.9 → 1.0.0rc1

data/lib/r10k/module.rb

@@ -1,9 +1,10 @@
 require 'r10k'
 
-class R10K::Module
+module R10K::Module
 
   # Register an inheriting  class for later generation
-  def self.inherited(klass)
+  def self.included(klass)
+    klass.extend self
     @klasses ||= []
     @klasses << klass
   end
@@ -16,28 +17,24 @@ class R10K::Module
   # with `name, args`, and generates an object of that class.
   #
   # @param [String] name The unique name of the module
-  # @param [String] path The root path to install the module in
+  # @param [String] basedir The root to install the module in
   # @param [Object] args An arbitary value or set of values that specifies the implementation
   #
   # @return [Object < R10K::Module] A member of the implementing subclass
-  def self.new(name, path, args)
-    if implementation = @klasses.find { |klass| klass.implements(name, args) }
-      obj = implementation.send(:allocate)
-      obj.send(:initialize, name, path, args)
+  def self.new(name, basedir, args)
+    if implementation = @klasses.find { |klass| klass.implement?(name, args) }
+      obj = implementation.new(name, basedir, args)
       obj
     else
       raise "Module #{name} with args #{args.inspect} doesn't have an implementation. (Are you using the right arguments?)"
     end
   end
 
-  attr_accessor :name, :path
-
-  def initialize(name, path, args)
-    @name, @path, @args = name, path, args
-  end
+  attr_accessor :name, :basedir
 
+  # @return [String] The full filesystem path to the module.
   def full_path
-    File.join(@path, @name)
+    File.join(@basedir, @name)
   end
 end
 

data/lib/r10k/module/forge.rb

@@ -7,70 +7,81 @@ require 'systemu'
 require 'semver'
 require 'json'
 
-class R10K::Module::Forge < R10K::Module
+module R10K
+module Module
+class Forge
 
-  def self.implements(name, args)
-    args.is_a? String and SemVer.valid?(args)
+  include R10K::Module
+
+  def self.implement?(name, args)
+    !!(name.match %r[\w+/\w+])
   end
 
   include R10K::Logging
 
-  def initialize(name, path, args)
-    super
+  attr_accessor :version, :owner, :full_name
 
+  def initialize(name, basedir, args)
     @full_name = name
+    @basedir   = basedir
 
     @owner, @name = name.split('/')
-    @version = SemVer.new(@args)
+
+    if args.is_a? String
+      @version = SemVer.new(args)
+    end
   end
 
-  def sync!(options = {})
+  def sync(options = {})
     return if insync?
 
     if insync?
-      logger.debug1 "Module #{@full_name} already matches version #{@version}"
+      #logger.debug1 "Module #{@full_name} already matches version #{@version}"
     elsif File.exist? metadata_path
-      logger.debug "Module #{@full_name} is installed but doesn't match version #{@version}, upgrading"
+      #logger.debug "Module #{@full_name} is installed but doesn't match version #{@version}, upgrading"
       cmd = []
       cmd << 'upgrade'
-      cmd << "--version=#{@version}"
+      cmd << "--version=#{@version}" if @version
       cmd << "--ignore-dependencies"
       cmd << @full_name
       pmt cmd
     else
-      logger.debug "Module #{@full_name} is not installed"
+      #logger.debug "Module #{@full_name} is not installed"
       cmd = []
       cmd << 'install'
-      cmd << "--version=#{@version}"
+      cmd << "--version=#{@version}" if @version
       cmd << "--ignore-dependencies"
       cmd << @full_name
       pmt cmd
     end
   end
 
-  private
-
-  def current_version
-    SemVer.new(metadata['version'])
+  # @return [SemVer, NilClass]
+  def version
+    if metadata
+      SemVer.new(metadata['version'])
+    else
+      SemVer::MIN
+    end
   end
 
   def insync?
-    @version == current_version
-  rescue
-    false
+    @version == version
   end
 
   def metadata
-    JSON.parse(File.read(metadata_path))
+    @metadata = JSON.parse(File.read(metadata_path)) rescue nil
   end
 
   def metadata_path
     File.join(full_path, 'metadata.json')
   end
 
+  private
+
   def pmt(args)
-    cmd = "puppet module --modulepath '#{@path}' #{args.join(' ')}"
-    log_event = "puppet module #{args.join(' ')}, modulepath: #{@path.inspect}"
+    cmd = "puppet module --modulepath '#{@basedir}' #{args.join(' ')}"
+    log_event = "puppet module #{args.join(' ')}, modulepath: #{@basedir.inspect}"
     logger.debug1 "Execute: #{cmd}"
 
     status, stdout, stderr = systemu(cmd)
@@ -88,3 +99,5 @@ class R10K::Module::Forge < R10K::Module
     stdout
   end
 end
+end
+end

data/lib/r10k/module/git.rb

@@ -1,24 +1,34 @@
 require 'r10k'
 require 'r10k/module'
-require 'r10k/synchro/git'
+require 'r10k/git/working_dir'
+require 'forwardable'
 
-class R10K::Module::Git < R10K::Module
+module R10K
+module Module
+class Git
+  include R10K::Module
 
-  def self.implements(name, args)
+  def self.implement?(name, args)
     args.is_a? Hash and args.has_key?(:git)
   rescue
     false
   end
 
-  def initialize(name, path, args)
-    super
+  extend Forwardable
+  def_delegator :@working_dir, :sync
+
+  def initialize(name, basedir, args)
+    @name, @basedir, @args = name, basedir, args
 
     @remote = @args[:git]
     @ref    = (@args[:ref] || 'master')
+
+    @working_dir = R10K::Git::WorkingDir.new(@ref, @remote, @basedir, @name)
   end
 
-  def sync!(options = {})
-    synchro = R10K::Synchro::Git.new(@remote)
-    synchro.sync(full_path, @ref, options)
+  def version
+    @ref
   end
 end
+end
+end

data/lib/r10k/puppetfile.rb

@@ -0,0 +1,107 @@
+require 'r10k/module'
+require 'r10k/logging'
+require 'r10k/util/purgeable'
+
+module R10K
+class Puppetfile
+  # Defines the data members of a Puppetfile
+
+  include R10K::Logging
+
+  # @!attribute [r] forge
+  #   @return [String] The URL to use for the Puppet Forge
+  attr_reader :forge
+
+  # @!attribute [r] modules
+  #   @return [Array<R10K::Module>]
+  attr_reader :modules
+
+  # @!attribute [r] basedir
+  #   @return [String] The base directory that contains the Puppetfile
+  attr_reader :basedir
+
+  # @!attribute [r] moduledir
+  #   @return [String] The directory to install the modules #{basedir}/modules
+  attr_reader :moduledir
+
+  # @!attrbute [r] puppetfile_path
+  #   @return [String] The path to the Puppetfile
+  attr_reader :puppetfile_path
+
+  # @param [String] basedir
+  # @param [String] puppetfile The path to the Puppetfile, default to #{basedir}/Puppetfile
+  def initialize(basedir, moduledir = nil, puppetfile = nil)
+    @basedir         = basedir
+    @moduledir       = moduledir  || File.join(basedir, 'modules')
+    @puppetfile_path = puppetfile || File.join(basedir, 'Puppetfile')
+
+    @modules = []
+    @forge   = 'forge.puppetlabs.com'
+  end
+
+  def load
+    if File.readable? @puppetfile_path
+      self.load!
+    else
+      logger.debug "Puppetfile #{@puppetfile_path.inspect} missing or unreadable"
+    end
+  end
+
+  def load!
+    dsl = R10K::Puppetfile::DSL.new(self)
+    dsl.instance_eval(puppetfile_contents, @puppetfile_path)
+  end
+
+  # @param [String] forge
+  def set_forge(forge)
+    @forge = forge
+  end
+
+  # @param [String] name
+  # @param [*Object] args
+  def add_module(name, args)
+    @modules << R10K::Module.new(name, @moduledir, args)
+  end
+
+  include R10K::Util::Purgeable
+
+  def managed_directory
+    @moduledir
+  end
+
+  # List all modules that should exist in the module directory
+  # @note This implements a required method for the Purgeable mixin
+  # @return [Array<String>]
+  def desired_contents
+    @modules.map { |mod| mod.name }
+  end
+
+  private
+
+  def puppetfile_contents
+    File.read(@puppetfile_path)
+  end
+
+  class DSL
+    # A barebones implementation of the Puppetfile DSL
+    #
+    # @api private
+
+    def initialize(librarian)
+      @librarian = librarian
+    end
+
+    def mod(name, args = [])
+      @librarian.add_module(name, args)
+    end
+
+    def forge(location)
+      @librarian.set_forge(location)
+    end
+
+    def method_missing(method, *args)
+      raise NoMethodError, "unrecognized declaration '#{method}'"
+    end
+  end
+end
+end

data/lib/r10k/task.rb

@@ -0,0 +1,13 @@
+require 'r10k/logging'
+
+module R10K
+module Task
+  class Base
+    include R10K::Logging
+
+    # @!attribute [r] task_runner
+    #   @return [R10K::TaskRunner] The task runner that's executing this command
+    attr_accessor :task_runner
+  end
+end
+end

data/lib/r10k/task/deployment.rb

@@ -0,0 +1,151 @@
+require 'r10k/task'
+require 'r10k/task_runner'
+
+require 'r10k/task/environment'
+require 'r10k/task/puppetfile'
+
+module R10K
+module Task
+module Deployment
+  module SharedBehaviors
+
+    private
+
+    def load_environments!
+      @environments = @deployment.environments.inject({}) do |hash, env|
+        hash[env.dirname] = env
+        hash
+      end
+    end
+
+    # @param [Array<String>] names The list of environments to deploy.
+    #
+    def with_environments(names = [], &block)
+      load_environments!
+
+      # If an explicit list of environments were not given, deploy everything
+      if names.size > 0
+        to_deploy = names
+      else
+        to_deploy = @environments.keys
+      end
+
+      to_deploy.each do |env_name|
+        if (env = @environments[env_name])
+          yield env
+        else
+          logger.warn "Environment #{env_name} not found in any source"
+          task_runner.succeeded = false
+        end
+      end
+    end
+  end
+
+  class DeployEnvironments < R10K::Task::Base
+
+    include SharedBehaviors
+
+    # @!attribute environment_names
+    #   @return [Array<String>] A list of environments to deploy, by name.
+    attr_accessor :environment_names
+
+    # @!attribute update_puppetfile
+    #   @return [TrueClass, FalseClass] Whether to deploy modules in a puppetfile
+    attr_accessor :update_puppetfile
+
+    def initialize(deployment)
+      @deployment = deployment
+      @update_puppetfile = false
+      @environment_names = []
+    end
+
+    def call
+      logger.info "Loading environments from all sources"
+      @deployment.fetch_sources
+
+      with_environments(@environment_names) do |env|
+        task = R10K::Task::Environment::Deploy.new(env)
+        task.update_puppetfile = @update_puppetfile
+        task_runner.insert_task_after(self, task)
+      end
+    end
+  end
+
+  class DeployModules < R10K::Task::Base
+
+    include SharedBehaviors
+
+    attr_accessor :module_names
+
+    # @!attribute environment_names
+    #   @return [Array<String>] A list of environments to update modules
+    attr_accessor :environment_names
+
+    def initialize(deployment)
+      @deployment        = deployment
+      @environment_names = []
+    end
+
+    def call
+      with_environments(@environment_names) do |env|
+        puppetfile = env.puppetfile
+
+        task = R10K::Task::Puppetfile::DeployModules.new(puppetfile)
+        task.module_names = module_names
+
+        task_runner.insert_task_after(self, task)
+      end
+    end
+  end
+
+  class PurgeEnvironments < R10K::Task::Base
+
+    def initialize(deployment)
+      @deployment = deployment
+    end
+
+    def call
+      @deployment.sources.each do |source|
+        stale_envs = source.stale_contents
+
+        dir = source.managed_directory
+
+        if stale_envs.empty?
+          logger.debug "No stale environments in #{dir}"
+        else
+          logger.info "Purging stale environments from #{dir}"
+          logger.debug "Stale modules in #{dir}: #{stale_envs.join(', ')}"
+          source.purge!
+        end
+      end
+    end
+  end
+
+  class Display < R10K::Task::Base
+
+    attr_accessor :puppetfile
+
+    def initialize(deployment)
+      @deployment = deployment
+    end
+
+    def call
+      @deployment.environments.each do |env|
+
+        puts "  - #{env.dirname}"
+
+        if @puppetfile
+          puppetfile = env.puppetfile
+          puppetfile.load
+
+          puppetfile.modules.each do |mod|
+            puts "    - #{mod.name} (#{mod.version})"
+          end
+        end
+      end
+    end
+  end
+end
+end
+end
+