puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/module.rb

@@ -0,0 +1,314 @@
+require 'puppet/util/logging'
+require 'semver'
+require 'puppet/module_tool/applications'
+
+# Support for modules
+class Puppet::Module
+  class Error < Puppet::Error; end
+  class MissingModule < Error; end
+  class IncompatibleModule < Error; end
+  class UnsupportedPlatform < Error; end
+  class IncompatiblePlatform < Error; end
+  class MissingMetadata < Error; end
+  class InvalidName < Error; end
+
+  include Puppet::Util::Logging
+
+  TEMPLATES = "templates"
+  FILES = "files"
+  MANIFESTS = "manifests"
+  PLUGINS = "plugins"
+
+  FILETYPES = [MANIFESTS, FILES, TEMPLATES, PLUGINS]
+
+  # Find and return the +module+ that +path+ belongs to. If +path+ is
+  # absolute, or if there is no module whose name is the first component
+  # of +path+, return +nil+
+  def self.find(modname, environment = nil)
+    return nil unless modname
+    Puppet::Node::Environment.new(environment).module(modname)
+  end
+
+  attr_reader :name, :environment
+  attr_writer :environment
+
+  attr_accessor :dependencies, :forge_name
+  attr_accessor :source, :author, :version, :license, :puppetversion, :summary, :description, :project_page
+
+  def has_metadata?
+    return false unless metadata_file
+
+    return false unless FileTest.exist?(metadata_file)
+
+    metadata = PSON.parse File.read(metadata_file)
+
+
+    return metadata.is_a?(Hash) && !metadata.keys.empty?
+  end
+
+  def initialize(name, options = {})
+    @name = name
+    @path = options[:path]
+
+    assert_validity
+
+    if options[:environment].is_a?(Puppet::Node::Environment)
+      @environment = options[:environment]
+    else
+      @environment = Puppet::Node::Environment.new(options[:environment])
+    end
+
+    load_metadata if has_metadata?
+
+    validate_puppet_version
+  end
+
+  FILETYPES.each do |type|
+    # A boolean method to let external callers determine if
+    # we have files of a given type.
+    define_method(type +'?') do
+      return false unless path
+      return false unless FileTest.exist?(subpath(type))
+      return true
+    end
+
+    # A method for returning a given file of a given type.
+    # e.g., file = mod.manifest("my/manifest.pp")
+    #
+    # If the file name is nil, then the base directory for the
+    # file type is passed; this is used for fileserving.
+    define_method(type.to_s.sub(/s$/, '')) do |file|
+      return nil unless path
+
+      # If 'file' is nil then they're asking for the base path.
+      # This is used for things like fileserving.
+      if file
+        full_path = File.join(subpath(type), file)
+      else
+        full_path = subpath(type)
+      end
+
+      return nil unless FileTest.exist?(full_path)
+      return full_path
+    end
+  end
+
+  def exist?
+    ! path.nil?
+  end
+
+  # Find the first 'files' directory.  This is used by the XMLRPC fileserver.
+  def file_directory
+    subpath("files")
+  end
+
+  def license_file
+    return @license_file if defined?(@license_file)
+
+    return @license_file = nil unless path
+    @license_file = File.join(path, "License")
+  end
+
+  def load_metadata
+    data = PSON.parse File.read(metadata_file)
+    @forge_name = data['name'].gsub('-', '/') if data['name']
+
+    [:source, :author, :version, :license, :puppetversion, :dependencies].each do |attr|
+      unless value = data[attr.to_s]
+        unless attr == :puppetversion
+          raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
+        end
+      end
+
+      # NOTICE: The fallback to `versionRequirement` is something we'd like to
+      # not have to support, but we have a reasonable number of releases that
+      # don't use `version_requirement`. When we can deprecate this, we should.
+      if attr == :dependencies
+        value.tap do |dependencies|
+          dependencies.each do |dep|
+            dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
+          end
+        end
+      end
+
+      send(attr.to_s + "=", value)
+    end
+  end
+
+  # Return the list of manifests matching the given glob pattern,
+  # defaulting to 'init.{pp,rb}' for empty modules.
+  def match_manifests(rest)
+    pat = File.join(path, MANIFESTS, rest || 'init')
+    [manifest("init.pp"),manifest("init.rb")].compact + Dir.
+      glob(pat + (File.extname(pat).empty? ? '.{pp,rb}' : '')).
+      reject { |f| FileTest.directory?(f) }
+  end
+
+  def metadata_file
+    return @metadata_file if defined?(@metadata_file)
+
+    return @metadata_file = nil unless path
+    @metadata_file = File.join(path, "metadata.json")
+  end
+
+  # Find this module in the modulepath.
+  def path
+    @path ||= environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.directory?(d) }
+  end
+
+  def modulepath
+    File.dirname(path) if path
+  end
+
+  # Find all plugin directories.  This is used by the Plugins fileserving mount.
+  def plugin_directory
+    subpath("plugins")
+  end
+
+  def supports(name, version = nil)
+    @supports ||= []
+    @supports << [name, version]
+  end
+
+  def to_s
+    result = "Module #{name}"
+    result += "(#{path})" if path
+    result
+  end
+
+  def dependencies_as_modules
+    dependent_modules = []
+    dependencies and dependencies.each do |dep|
+      author, dep_name = dep["name"].split('/')
+      found_module = environment.module(dep_name)
+      dependent_modules << found_module if found_module
+    end
+
+    dependent_modules
+  end
+
+  def required_by
+    environment.module_requirements[self.forge_name] || {}
+  end
+
+  def has_local_changes?
+    changes = Puppet::ModuleTool::Applications::Checksummer.run(path)
+    !changes.empty?
+  end
+
+  def local_changes
+    Puppet::ModuleTool::Applications::Checksummer.run(path)
+  end
+
+  # Identify and mark unmet dependencies.  A dependency will be marked unmet
+  # for the following reasons:
+  #
+  #   * not installed and is thus considered missing
+  #   * installed and does not meet the version requirements for this module
+  #   * installed and doesn't use semantic versioning
+  #
+  # Returns a list of hashes representing the details of an unmet dependency.
+  #
+  # Example:
+  #
+  #   [
+  #     {
+  #       :reason => :missing,
+  #       :name   => 'puppetlabs-mysql',
+  #       :version_constraint => 'v0.0.1',
+  #       :mod_details => {
+  #         :installed_version => '0.0.1'
+  #       }
+  #       :parent => {
+  #         :name    => 'puppetlabs-bacula',
+  #         :version => 'v1.0.0'
+  #       }
+  #     }
+  #   ]
+  #
+  def unmet_dependencies
+    unmet_dependencies = []
+    return unmet_dependencies unless dependencies
+
+    dependencies.each do |dependency|
+      forge_name = dependency['name']
+      version_string = dependency['version_requirement'] || '>= 0.0.0'
+
+      dep_mod = begin
+        environment.module_by_forge_name(forge_name)
+      rescue => e
+        nil
+      end
+
+      error_details = {
+        :name => forge_name,
+        :version_constraint => version_string.gsub(/^(?=\d)/, "v"),
+        :parent => {
+          :name => self.forge_name,
+          :version => self.version.gsub(/^(?=\d)/, "v")
+        },
+        :mod_details => {
+          :installed_version => dep_mod.nil? ? nil : dep_mod.version
+        }
+      }
+
+      unless dep_mod
+        error_details[:reason] = :missing
+        unmet_dependencies << error_details
+        next
+      end
+
+      if version_string
+        begin
+          required_version_semver_range = SemVer[version_string]
+          actual_version_semver = SemVer.new(dep_mod.version)
+        rescue ArgumentError
+          error_details[:reason] = :non_semantic_version
+          unmet_dependencies << error_details
+          next
+        end
+
+        unless required_version_semver_range.include? actual_version_semver
+          error_details[:reason] = :version_mismatch
+          unmet_dependencies << error_details
+          next
+        end
+      end
+    end
+
+    unmet_dependencies
+  end
+
+  def validate_puppet_version
+    return unless puppetversion and puppetversion != Puppet.version
+    raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
+  end
+
+  private
+
+  def subpath(type)
+    return File.join(path, type) unless type.to_s == "plugins"
+
+    backward_compatible_plugins_dir
+  end
+
+  def backward_compatible_plugins_dir
+    if dir = File.join(path, "plugins") and FileTest.exist?(dir)
+      Puppet.warning "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
+      return dir
+    else
+      return File.join(path, "lib")
+    end
+  end
+
+  def assert_validity
+    raise InvalidName, "Invalid module name #{name}; module names must be alphanumeric (plus '-'), not '#{name}'" unless name =~ /^[-\w]+$/
+  end
+
+  def ==(other)
+    self.name == other.name &&
+    self.version == other.version &&
+    self.path == other.path &&
+    self.environment == other.environment
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'net/http'
+require 'semver'
+require 'puppet/util/colors'
+
+module Puppet::ModuleTool
+  module Applications
+    class Application
+      include Puppet::Util::Colors
+
+      def self.run(*args)
+        new(*args).run
+      end
+
+      attr_accessor :options
+
+      def initialize(options = {})
+        if Puppet.features.microsoft_windows?
+          raise Puppet::Error, "`puppet module` actions are currently not supported on Microsoft Windows"
+        end
+        @options = options
+      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::ModuleTool::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::ModuleTool::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
+
+      def parse_filename(filename)
+        if match = /^((.*?)-(.*?))-(\d+\.\d+\.\d+.*?)$/.match(File.basename(filename,'.tar.gz'))
+          module_name, author, shortname, version = match.captures
+        else
+          raise ArgumentError, "Could not parse filename to obtain the username, module name and version.  (#{@release_name})"
+        end
+
+        unless SemVer.valid?(version)
+          raise ArgumentError, "Invalid version format: #{version} (Semantic Versions are acceptable: http://semver.org)"
+        end
+
+        return {
+          :module_name => module_name,
+          :author      => author,
+          :dir_name    => shortname,
+          :version     => version
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'fileutils'
+
+module Puppet::ModuleTool
+  module Applications
+    class Builder < Application
+
+      def initialize(path, options = {})
+        @path = File.expand_path(Puppet::ModuleTool.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, :secure => true)
+        end
+        FileUtils.mkdir(build_path)
+      end
+
+      def copy_contents
+        Dir[File.join(@path, '*')].each do |path|
+          case File.basename(path)
+          when *Puppet::ModuleTool::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

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

@@ -0,0 +1,56 @@
+require 'puppet/module_tool/checksums'
+
+module Puppet::ModuleTool
+  module Applications
+    class Checksummer < Application
+
+      def initialize(path, options = {})
+        @path = Pathname.new(path)
+        super(options)
+      end
+
+      def run
+        changes = []
+        if metadata_file.exist?
+          sums = Puppet::ModuleTool::Checksums.new(@path)
+          (metadata['checksums'] || {}).each do |child_path, canonical_checksum|
+
+            # Work around an issue where modules built with an older version
+            # of PMT would include the metadata.json file in the list of files
+            # checksummed. This causes metadata.json to always report local
+            # changes.
+            next if File.basename(child_path) == "metadata.json"
+
+            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", "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/vendor/puppet/module_tool/applications/generator.rb

@@ -0,0 +1,141 @@
+require 'pathname'
+require 'fileutils'
+require 'erb'
+
+module Puppet::ModuleTool
+  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