puppet 2.7.8 → 2.7.9

data/lib/puppet/face/module/generate.rb

@@ -0,0 +1,40 @@
+Puppet::Face.define(:module, '1.0.0') do
+  action(:generate) do
+    summary "Generate boilerplate for a new module."
+    description <<-EOT
+      Generate boilerplate for a new module by creating a directory
+      pre-populated with a directory structure and files recommended for
+      Puppet best practices.
+    EOT
+
+    returns "Array of Pathname objects representing paths of generated files."
+
+    examples <<-EOT
+      Generate a new module in the current directory:
+
+      $ puppet module generate puppetlabs-ssh
+      notice: Generating module at /Users/kelseyhightower/puppetlabs-ssh
+      puppetlabs-ssh
+      puppetlabs-ssh/tests
+      puppetlabs-ssh/tests/init.pp
+      puppetlabs-ssh/spec
+      puppetlabs-ssh/spec/spec_helper.rb
+      puppetlabs-ssh/spec/spec.opts
+      puppetlabs-ssh/README
+      puppetlabs-ssh/Modulefile
+      puppetlabs-ssh/metadata.json
+      puppetlabs-ssh/manifests
+      puppetlabs-ssh/manifests/init.pp
+    EOT
+
+    arguments "<name>"
+
+    when_invoked do |name, options|
+      Puppet::Module::Tool::Applications::Generator.run(name, options)
+    end
+
+    when_rendering :console do |return_value|
+      return_value.map {|f| f.to_s }.join("\n")
+    end
+  end
+end

data/lib/puppet/face/module/install.rb

@@ -0,0 +1,83 @@
+Puppet::Face.define(:module, '1.0.0') do
+  action(:install) do
+    summary "Install a module from a repository or release archive."
+    description <<-EOT
+      Install a module from a release archive file on-disk or by downloading
+      one from a repository. Unpack the archive into the install directory
+      specified by the --install-dir option, which defaults to
+      #{Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).first}
+    EOT
+
+    returns "Pathname object representing the path to the installed module."
+
+    examples <<-EOT
+      Install a module from the default repository:
+
+      $ puppet module install puppetlabs/vcsrepo
+      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /etc/puppet/modules/vcsrepo
+      /etc/puppet/modules/vcsrepo
+
+      Install a specific module version from a repository:
+
+      $ puppet module install puppetlabs/vcsrepo -v 0.0.4
+      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /etc/puppet/modules/vcsrepo
+      /etc/puppet/modules/vcsrepo
+
+      Install a module into a specific directory:
+
+      $ puppet module install puppetlabs/vcsrepo --install-dir=/usr/share/puppet/modules
+      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /usr/share/puppet/modules/vcsrepo
+      /usr/share/puppet/modules/vcsrepo
+
+      Install a module from a release archive:
+
+      $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz
+      notice: Installing puppetlabs-vcsrepo-0.0.4.tar.gz to /etc/puppet/modules/vcsrepo
+      /etc/puppet/modules/vcsrepo
+    EOT
+
+    arguments "<name>"
+
+    option "--force", "-f" do
+      summary "Force overwrite of existing module, if any."
+      description <<-EOT
+        Force overwrite of existing module, if any.
+      EOT
+    end
+
+    option "--install-dir=", "-i=" do
+      default_to { Puppet.settings[:modulepath].split(File::PATH_SEPARATOR).first }
+      summary "The directory into which modules are installed."
+      description <<-EOT
+        The directory into which modules are installed, defaults to the first
+        directory in the modulepath.
+      EOT
+    end
+
+    option "--module-repository=", "-r=" do
+      default_to { Puppet.settings[:module_repository] }
+      summary "Module repository to use."
+      description <<-EOT
+        Module repository to use.
+      EOT
+    end
+
+    option "--version=", "-v=" do
+      summary "Module version to install."
+      description <<-EOT
+        Module version to install, can be a requirement string, eg '>= 1.0.3',
+        defaults to latest version.
+      EOT
+    end
+
+    when_invoked do |name, options|
+      Puppet::Module::Tool::Applications::Installer.run(name, options)
+    end
+
+    when_rendering :console do |return_value|
+      # Get the string representation of the Pathname object and print it to
+      # the console.
+      return_value.to_s
+    end
+  end
+end

data/lib/puppet/face/module/search.rb

@@ -0,0 +1,66 @@
+Puppet::Face.define(:module, '1.0.0') do
+  action(:search) do
+    summary "Search a repository for a module."
+    description <<-EOT
+      Search a repository for modules whose names match a specific substring.
+    EOT
+
+    returns "Array of module metadata hashes"
+
+    examples <<-EOT
+      Search the default repository for a module:
+
+      $ puppet module search puppetlabs
+      notice: Searching http://forge.puppetlabs.com
+      notice: 24 found.
+      puppetlabs/apache (0.0.3)
+      puppetlabs/collectd (0.0.1)
+      puppetlabs/ruby (0.0.1)
+      puppetlabs/vcsrepo (0.0.4)
+      puppetlabs/gcc (0.0.3)
+      puppetlabs/passenger (0.0.2)
+      puppetlabs/DeveloperBootstrap (0.0.5)
+      jeffmccune/tomcat (1.0.1)
+      puppetlabs/motd (1.0.0)
+      puppetlabs/lvm (0.1.0)
+      puppetlabs/rabbitmq (1.0.4)
+      puppetlabs/prosvc_repo (1.0.1)
+      puppetlabs/stdlib (2.2.0)
+      puppetlabs/java (0.1.5)
+      puppetlabs/activemq (0.1.6)
+      puppetlabs/mcollective (0.1.8)
+      puppetlabs/git (0.0.2)
+      puppetlabs/ntp (0.0.4)
+      puppetlabs/nginx (0.0.1)
+      puppetlabs/cloud_provisioner (0.6.0rc1)
+      puppetlabs/mrepo (0.1.1)
+      puppetlabs/f5 (0.1.0)
+      puppetlabs/firewall (0.0.3)
+      puppetlabs/bprobe (0.0.3)
+    EOT
+
+    arguments "<term>"
+
+    option "--module-repository=", "-r=" do
+      default_to { Puppet.settings[:module_repository] }
+      summary "Module repository to use."
+      description <<-EOT
+        Module repository to use.
+      EOT
+    end
+
+    when_invoked do |term, options|
+      Puppet.notice "Searching #{options[:module_repository]}"
+      Puppet::Module::Tool::Applications::Searcher.run(term, options)
+    end
+
+    when_rendering :console do |return_value|
+      Puppet.notice "#{return_value.size} found."
+      return_value.map do |match|
+        # We reference the full_name here when referring to the full_module_name,
+        # because full_name is what is returned from the forge API call.
+        "#{match['full_name']} (#{match['version']})"
+      end.join("\n")
+    end
+  end
+end

data/lib/puppet/indirector/exec.rb

@@ -39,7 +39,7 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     end
 
     if output =~ /\A\s*\Z/ # all whitespace
-      Puppet.debug "Empty response for #{name} from exec #{self.name} terminus"
+      Puppet.debug "Empty response for #{name} from #{self.name} terminus"
       return nil
     else
       return output

data/lib/puppet/module_tool.rb

@@ -0,0 +1,97 @@
+# Load standard libraries
+require 'pathname'
+require 'fileutils'
+require 'puppet/module_tool/utils'
+
+# Define tool
+module Puppet
+  class Module
+    module Tool
+
+      # Directory names that should not be checksummed.
+      ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage']
+      FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
+      REPOSITORY_URL = Puppet.settings[:module_repository]
+
+      # Is this a directory that shouldn't be checksummed?
+      #
+      # TODO: Should this be part of Checksums?
+      # TODO: Rename this method to reflect it's purpose?
+      # TODO: Shouldn't this be used when building packages too?
+      def self.artifact?(path)
+        case File.basename(path)
+        when *ARTIFACTS
+          true
+        else
+          false
+        end
+      end
+
+      # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
+      # ArgumentError if the argument isn't parseable.
+      def self.username_and_modname_from(full_module_name)
+        if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
+          return matcher.captures
+        else
+          raise ArgumentError, "Not a valid full name: #{full_module_name}"
+        end
+      end
+
+      # Read HTTP proxy configurationm from Puppet's config file, or the
+      # http_proxy environment variable.
+      def self.http_proxy_env
+        proxy_env = ENV["http_proxy"] || ENV["HTTP_PROXY"] || nil
+        begin
+          return URI.parse(proxy_env) if proxy_env
+        rescue URI::InvalidURIError
+          return nil
+        end
+        return nil
+      end
+
+      def self.http_proxy_host
+        env = http_proxy_env
+
+        if env and env.host then
+          return env.host
+        end
+
+        if Puppet.settings[:http_proxy_host] == 'none'
+          return nil
+        end
+
+        return Puppet.settings[:http_proxy_host]
+      end
+
+      def self.http_proxy_port
+        env = http_proxy_env
+
+        if env and env.port then
+          return env.port
+        end
+
+        return Puppet.settings[:http_proxy_port]
+      end
+
+      def self.find_module_root(path)
+        for dir in [path, Dir.pwd].compact
+          if File.exist?(File.join(dir, 'Modulefile'))
+            return dir
+          end
+        end
+        raise ArgumentError, "Could not find a valid module at #{path ? path.inspect : 'current directory'}"
+      end
+    end
+  end
+end
+
+# Load remaining libraries
+require 'puppet/module_tool/applications'
+require 'puppet/module_tool/cache'
+require 'puppet/module_tool/checksums'
+require 'puppet/module_tool/contents_description'
+require 'puppet/module_tool/dependency'
+require 'puppet/module_tool/metadata'
+require 'puppet/module_tool/modulefile'
+require 'puppet/module_tool/repository'
+require 'puppet/module_tool/skeleton'

data/lib/puppet/module_tool/applications.rb

@@ -0,0 +1,12 @@
+module Puppet::Module::Tool
+  module Applications
+    require 'puppet/module_tool/applications/application'
+    require 'puppet/module_tool/applications/builder'
+    require 'puppet/module_tool/applications/checksummer'
+    require 'puppet/module_tool/applications/cleaner'
+    require 'puppet/module_tool/applications/generator'
+    require 'puppet/module_tool/applications/installer'
+    require 'puppet/module_tool/applications/searcher'
+    require 'puppet/module_tool/applications/unpacker'
+  end
+end

data/lib/puppet/module_tool/applications/application.rb

@@ -0,0 +1,83 @@
+require 'net/http'
+require 'semver'
+
+module Puppet::Module::Tool
+  module Applications
+    class Application
+      include Utils::Interrogation
+
+      def self.run(*args)
+        new(*args).run
+      end
+
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def repository
+        @repository ||= Repository.new(@options[:module_repository])
+      end
+
+      def run
+        raise NotImplementedError, "Should be implemented in child classes."
+      end
+
+      def discuss(response, success, failure)
+        case response
+        when Net::HTTPOK, Net::HTTPCreated
+          Puppet.notice success
+        else
+          errors = PSON.parse(response.body)['error'] rescue "HTTP #{response.code}, #{response.body}"
+          Puppet.warning "#{failure} (#{errors})"
+        end
+      end
+
+      def metadata(require_modulefile = false)
+        unless @metadata
+          unless @path
+            raise ArgumentError, "Could not determine module path"
+          end
+          @metadata = Puppet::Module::Tool::Metadata.new
+          contents = ContentsDescription.new(@path)
+          contents.annotate(@metadata)
+          checksums = Checksums.new(@path)
+          checksums.annotate(@metadata)
+          modulefile_path = File.join(@path, 'Modulefile')
+          if File.file?(modulefile_path)
+            Puppet::Module::Tool::ModulefileReader.evaluate(@metadata, modulefile_path)
+          elsif require_modulefile
+            raise ArgumentError, "No Modulefile found."
+          end
+        end
+        @metadata
+      end
+
+      def load_modulefile!
+        @metadata = nil
+        metadata(true)
+      end
+
+      # Use to extract and validate a module name and version from a
+      # filename
+      # Note: Must have @filename set to use this
+      def parse_filename!
+        @release_name = File.basename(@filename,'.tar.gz')
+        match = /^(.*?)-(.*?)-(\d+\.\d+\.\d+.*?)$/.match(@release_name)
+        if match then
+          @username, @module_name, @version = match.captures
+        else
+          raise ArgumentError, "Could not parse filename to obtain the username, module name and version.  (#{@release_name})"
+        end
+        @full_module_name = [@username, @module_name].join('-')
+        unless @username && @module_name
+          raise ArgumentError, "Username and Module name not provided"
+        end
+        unless SemVer.valid?(@version)
+          raise ArgumentError, "Invalid version format: #{@version} (Semantic Versions are acceptable: http://semver.org)"
+        end
+      end
+    end
+  end
+end

data/lib/puppet/module_tool/applications/builder.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+
+module Puppet::Module::Tool
+  module Applications
+    class Builder < Application
+
+      def initialize(path, options = {})
+        @path = File.expand_path(Puppet::Module::Tool.find_module_root(path))
+        @pkg_path = File.join(@path, 'pkg')
+        super(options)
+      end
+
+      def run
+        load_modulefile!
+        create_directory
+        copy_contents
+        add_metadata
+        Puppet.notice "Building #{@path} for release"
+        tar
+        gzip
+        relative = Pathname.new(File.join(@pkg_path, filename('tar.gz'))).relative_path_from(Pathname.new(Dir.pwd))
+
+        # Return the Pathname object representing the path to the release
+        # archive just created. This return value is used by the module_tool
+        # face build action, and displayed to on the console using the to_s
+        # method.
+        #
+        # Example return value:
+        #
+        #   <Pathname:puppetlabs-apache/pkg/puppetlabs-apache-0.0.1.tar.gz>
+        #
+        relative
+      end
+
+      private
+
+      def filename(ext)
+        ext.sub!(/^\./, '')
+        "#{metadata.release_name}.#{ext}"
+      end
+
+      def tar
+        tar_name = filename('tar')
+        Dir.chdir(@pkg_path) do
+          FileUtils.rm tar_name rescue nil
+          unless system "tar -cf #{tar_name} #{metadata.release_name}"
+            raise RuntimeError, "Could not create #{tar_name}"
+          end
+        end
+      end
+
+      def gzip
+        Dir.chdir(@pkg_path) do
+          FileUtils.rm filename('tar.gz') rescue nil
+          unless system "gzip #{filename('tar')}"
+            raise RuntimeError, "Could not compress #{filename('tar')}"
+          end
+        end
+      end
+
+      def create_directory
+        FileUtils.mkdir(@pkg_path) rescue nil
+        if File.directory?(build_path)
+          FileUtils.rm_rf(build_path)
+        end
+        FileUtils.mkdir(build_path)
+      end
+
+      def copy_contents
+        Dir[File.join(@path, '*')].each do |path|
+          case File.basename(path)
+          when *Puppet::Module::Tool::ARTIFACTS
+            next
+          else
+            FileUtils.cp_r path, build_path
+          end
+        end
+      end
+
+      def add_metadata
+        File.open(File.join(build_path, 'metadata.json'), 'w') do |f|
+          f.write(PSON.pretty_generate(metadata))
+        end
+      end
+
+      def build_path
+        @build_path ||= File.join(@pkg_path, metadata.release_name)
+      end
+    end
+  end
+end