puppet 2.7.8 → 2.7.9

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

@@ -0,0 +1,47 @@
+module Puppet::Module::Tool
+  module Applications
+    class Checksummer < Application
+
+      def initialize(path, options = {})
+        @path = Pathname.new(path)
+        super(options)
+      end
+
+      def run
+        changes = []
+        if metadata_file.exist?
+          sums = Checksums.new(@path)
+          (metadata['checksums'] || {}).each do |child_path, canonical_checksum|
+            path = @path + child_path
+            if canonical_checksum != sums.checksum(path)
+              changes << child_path
+            end
+          end
+        else
+          raise ArgumentError, "No metadata.json found."
+        end
+
+        # Return an Array of strings representing file paths of files that have
+        # been modified since this module was installed. All paths are relative
+        # to the installed module directory. This return value is used by the
+        # module_tool face changes action, and displayed on the console.
+        #
+        # Example return value:
+        #
+        #   [ "REVISION", "metadata.json", "manifests/init.pp"]
+        #
+        changes
+      end
+
+      private
+
+      def metadata
+        PSON.parse(metadata_file.read)
+      end
+
+      def metadata_file
+        (@path + 'metadata.json')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Puppet::Module::Tool
+  module Applications
+    class Cleaner < Application
+      def run
+        Puppet::Module::Tool::Cache.clean
+
+        # Return a status Hash containing the status of the clean command
+        # and a status message. This return value is used by the module_tool
+        # face clean action, and the status message, return_value[:msg], is
+        # displayed on the console.
+        #
+        { :status => "success", :msg => "Cleaned module cache." }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require 'pathname'
+require 'fileutils'
+require 'erb'
+
+module Puppet::Module::Tool
+  module Applications
+    class Generator < Application
+
+      def initialize(full_module_name, options = {})
+        begin
+          @metadata = Metadata.new(:full_module_name => full_module_name)
+        rescue ArgumentError
+          raise "Could not generate directory #{full_module_name.inspect}, you must specify a dash-separated username and module name."
+        end
+        super(options)
+      end
+
+      def skeleton
+        @skeleton ||= Skeleton.new
+      end
+
+      def get_binding
+        binding
+      end
+
+      def run
+        if destination.directory?
+          raise ArgumentError, "#{destination} already exists."
+        end
+        Puppet.notice "Generating module at #{Dir.pwd}/#{@metadata.dashed_name}"
+        files_created = []
+        skeleton.path.find do |path|
+          if path == skeleton
+            destination.mkpath
+          else
+            node = Node.on(path, self)
+            if node
+              node.install!
+              files_created << node.target
+            else
+              Puppet.notice "Could not generate from #{path}"
+            end
+          end
+        end
+
+        # Return an array of Pathname objects representing file paths of files
+        # and directories just generated. This return value is used by the
+        # module_tool face generate action, and displayed on the console.
+        #
+        # Example return value:
+        #
+        #   [
+        #     #<Pathname:puppetlabs-apache>,
+        #     #<Pathname:puppetlabs-apache/tests>,
+        #     #<Pathname:puppetlabs-apache/tests/init.pp>,
+        #     #<Pathname:puppetlabs-apache/spec>,
+        #     #<Pathname:puppetlabs-apache/spec/spec_helper.rb>,
+        #     #<Pathname:puppetlabs-apache/spec/spec.opts>,
+        #     #<Pathname:puppetlabs-apache/README>,
+        #     #<Pathname:puppetlabs-apache/Modulefile>,
+        #     #<Pathname:puppetlabs-apache/metadata.json>,
+        #     #<Pathname:puppetlabs-apache/manifests>,
+        #     #<Pathname:puppetlabs-apache/manifests/init.pp"
+        #   ]
+        #
+        files_created
+      end
+
+      def destination
+        @destination ||= Pathname.new(@metadata.dashed_name)
+      end
+
+      class Node
+        def self.types
+          @types ||= []
+        end
+        def self.inherited(klass)
+          types << klass
+        end
+        def self.on(path, generator)
+          klass = types.detect { |t| t.matches?(path) }
+          if klass
+            klass.new(path, generator)
+          end
+        end
+        def initialize(source, generator)
+          @generator = generator
+          @source = source
+        end
+        def read
+          @source.read
+        end
+        def target
+          target = @generator.destination + @source.relative_path_from(@generator.skeleton.path)
+          components = target.to_s.split(File::SEPARATOR).map do |part|
+            part == 'NAME' ? @generator.metadata.name : part
+          end
+          Pathname.new(components.join(File::SEPARATOR))
+        end
+        def install!
+          raise NotImplementedError, "Abstract"
+        end
+      end
+
+      class DirectoryNode < Node
+        def self.matches?(path)
+          path.directory?
+        end
+        def install!
+          target.mkpath
+        end
+      end
+
+      class ParsedFileNode < Node
+        def self.matches?(path)
+          path.file? && path.extname == '.erb'
+        end
+        def target
+          path = super
+          path.parent + path.basename('.erb')
+        end
+        def contents
+          template = ERB.new(read)
+          template.result(@generator.send(:get_binding))
+        end
+        def install!
+          target.open('w') { |f| f.write contents }
+        end
+      end
+
+      class FileNode < Node
+        def self.matches?(path)
+          path.file?
+        end
+        def install!
+          FileUtils.cp(@source, target)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'open-uri'
+require 'pathname'
+require 'tmpdir'
+
+module Puppet::Module::Tool
+  module Applications
+    class Installer < Application
+
+      def initialize(name, options = {})
+        if File.exist?(name)
+          if File.directory?(name)
+            # TODO Unify this handling with that of Unpacker#check_clobber!
+            raise ArgumentError, "Module already installed: #{name}"
+          end
+          @source = :filesystem
+          @filename = File.expand_path(name)
+          parse_filename!
+        else
+          @source = :repository
+          begin
+            @username, @module_name = Puppet::Module::Tool::username_and_modname_from(name)
+          rescue ArgumentError
+            raise "Could not install module with invalid name: #{name}"
+          end
+          @version_requirement = options[:version]
+        end
+        super(options)
+      end
+
+      def force?
+        options[:force]
+      end
+
+      def run
+        case @source
+        when :repository
+          if match['file']
+            begin
+              cache_path = repository.retrieve(match['file'])
+            rescue OpenURI::HTTPError => e
+              raise RuntimeError, "Could not install module: #{e.message}"
+            end
+            module_dir = Unpacker.run(cache_path, options)
+          else
+            raise RuntimeError, "Malformed response from module repository."
+          end
+        when :filesystem
+          repository = Repository.new('file:///')
+          uri = URI.parse("file://#{URI.escape(File.expand_path(@filename))}")
+          cache_path = repository.retrieve(uri)
+          module_dir = Unpacker.run(cache_path, options)
+        else
+          raise ArgumentError, "Could not determine installation source"
+        end
+
+        # Return the Pathname object representing the path to the installed
+        # module. This return value is used by the module_tool face install
+        # action, and displayed to on the console.
+        #
+        # Example return value:
+        #
+        #   "/etc/puppet/modules/apache"
+        #
+        module_dir
+      end
+
+      private
+
+      def match
+        return @match ||= begin
+          url = repository.uri + "/users/#{@username}/modules/#{@module_name}/releases/find.json"
+          if @version_requirement
+            url.query = "version=#{URI.escape(@version_requirement)}"
+          end
+          begin
+            raw_result = read_match(url)
+          rescue => e
+            raise ArgumentError, "Could not find a release for this module (#{e.message})"
+          end
+          @match = PSON.parse(raw_result)
+        end
+      end
+
+      def read_match(url)
+        return url.read
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Puppet::Module::Tool
+  module Applications
+    class Searcher < Application
+
+      def initialize(term, options = {})
+        @term = term
+        super(options)
+      end
+
+      def run
+        request = Net::HTTP::Get.new("/modules.json?q=#{URI.escape(@term)}")
+        response = repository.make_http_request(request)
+        case response
+        when Net::HTTPOK
+          matches = PSON.parse(response.body)
+        else
+          raise RuntimeError, "Could not execute search (HTTP #{response.code})"
+          matches = []
+        end
+
+        # Return a list of module metadata hashes that match the search query.
+        # This return value is used by the module_tool face install search,
+        # and displayed to on the console.
+        #
+        # Example return value:
+        #
+        # [
+        #   {
+        #     "name"        => "nginx",
+        #     "project_url" => "http://github.com/puppetlabs/puppetlabs-nginx",
+        #     "version"     => "0.0.1",
+        #     "full_name"   => "puppetlabs/nginx" # full_name comes back from
+        #   }                                     # API all to the forge.
+        # ]
+        #
+        matches
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'pathname'
+require 'tmpdir'
+
+module Puppet::Module::Tool
+  module Applications
+    class Unpacker < Application
+
+      def initialize(filename, options = {})
+        @filename = Pathname.new(filename)
+        parse_filename!
+        super(options)
+        @module_dir = Pathname.new(options[:install_dir]) + @module_name
+      end
+
+      def run
+        extract_module_to_install_dir
+        tag_revision
+
+        # Return the Pathname object representing the directory where the
+        # module release archive was unpacked the to, and the module release
+        # name.
+        @module_dir
+      end
+
+      private
+
+      def tag_revision
+        File.open("#{@module_dir}/REVISION", 'w') do |f|
+          f.puts "module: #{@username}/#{@module_name}"
+          f.puts "version: #{@version}"
+          f.puts "url: file://#{@filename.expand_path}"
+          f.puts "installed: #{Time.now}"
+        end
+      end
+
+      def extract_module_to_install_dir
+        delete_existing_installation_or_abort!
+
+        build_dir = Puppet::Module::Tool::Cache.base_path + "tmp-unpacker-#{Digest::SHA1.hexdigest(@filename.basename.to_s)}"
+        build_dir.mkpath
+        begin
+          Puppet.notice "Installing #{@filename.basename} to #{@module_dir.expand_path}"
+          unless system "tar xzf #{@filename} -C #{build_dir}"
+            raise RuntimeError, "Could not extract contents of module archive."
+          end
+          # grab the first directory
+          extracted = build_dir.children.detect { |c| c.directory? }
+          FileUtils.mv extracted, @module_dir
+        ensure
+          build_dir.rmtree
+        end
+      end
+
+      def delete_existing_installation_or_abort!
+        return unless @module_dir.exist?
+
+        if !options[:force]
+          Puppet.warning "Existing module '#{@module_dir.expand_path}' found"
+          response = prompt "Overwrite module installed at #{@module_dir.expand_path}? [y/N]"
+          unless response =~ /y/i
+            raise RuntimeError, "Aborted installation."
+          end
+        end
+
+        Puppet.warning "Deleting #{@module_dir.expand_path}"
+        FileUtils.rm_rf @module_dir
+      end
+    end
+  end
+end

data/lib/puppet/module_tool/cache.rb

@@ -0,0 +1,56 @@
+require 'uri'
+
+module Puppet::Module::Tool
+
+  # = Cache
+  #
+  # Provides methods for reading files from local cache, filesystem or network.
+  class Cache
+
+    # Instantiate new cahe for the +repositry+ instance.
+    def initialize(repository, options = {})
+      @repository = repository
+      @options = options
+    end
+
+    # Return filename retrieved from +uri+ instance. Will download this file and
+    # cache it if needed.
+    #
+    # TODO: Add checksum support.
+    # TODO: Add error checking.
+    def retrieve(url)
+      (path + File.basename(url.to_s)).tap do |cached_file|
+        uri = url.is_a?(::URI) ? url : ::URI.parse(url)
+        unless cached_file.file?
+          if uri.scheme == 'file'
+            FileUtils.cp(URI.unescape(uri.path), cached_file)
+          else
+            # TODO: Handle HTTPS; probably should use repository.contact
+            data = read_retrieve(uri)
+            cached_file.open('wb') { |f| f.write data }
+          end
+        end
+      end
+    end
+
+    # Return contents of file at the given URI's +uri+.
+    def read_retrieve(uri)
+      return uri.read
+    end
+
+    # Return Pathname for repository's cache directory, create it if needed.
+    def path
+      return @path ||= (self.class.base_path + @repository.cache_key).tap{ |o| o.mkpath }
+    end
+
+    # Return the base Pathname for all the caches.
+    def self.base_path
+      Pathname(Puppet.settings[:module_working_dir]) + 'cache'
+    end
+
+    # Clean out all the caches.
+    def self.clean
+      base_path.rmtree if base_path.exist?
+    end
+  end
+end