puppet 2.7.8 → 2.7.9

data/lib/puppet/module_tool/checksums.rb

@@ -0,0 +1,52 @@
+require 'digest/md5'
+
+module Puppet::Module::Tool
+
+  # = Checksums
+  #
+  # This class proides methods for generating checksums for data and adding
+  # them to +Metadata+.
+  class Checksums
+    include Enumerable
+
+    # Instantiate object with string +path+ to create checksums from.
+    def initialize(path)
+      @path = Pathname.new(path)
+    end
+
+    # Return checksum for the +Pathname+.
+    def checksum(pathname)
+      return Digest::MD5.hexdigest(pathname.read)
+    end
+
+    # Return checksums for object's +Pathname+, generate if it's needed.
+    # Result is a hash of path strings to checksum strings.
+    def data
+      unless @data
+        @data = {}
+        @path.find do |descendant|
+          if Puppet::Module::Tool.artifact?(descendant)
+            Find.prune
+          elsif descendant.file?
+            path = descendant.relative_path_from(@path)
+            @data[path.to_s] = checksum(descendant)
+          end
+        end
+      end
+      return @data
+    end
+
+    # TODO: Why?
+    def each(&block)
+      data.each(&block)
+    end
+
+    # Update +Metadata+'s checksums with this object's.
+    def annotate(metadata)
+      metadata.checksums.replace(data)
+    end
+
+    # TODO: Move the Checksummer#run checksum checking to here?
+
+  end
+end

data/lib/puppet/module_tool/contents_description.rb

@@ -0,0 +1,82 @@
+module Puppet::Module::Tool
+
+  # = ContentsDescription
+  #
+  # This class populates +Metadata+'s Puppet type information.
+  class ContentsDescription
+
+    # Instantiate object for string +module_path+.
+    def initialize(module_path)
+      @module_path = module_path
+    end
+
+    # Update +Metadata+'s Puppet type information.
+    def annotate(metadata)
+      metadata.types.replace data.clone
+    end
+
+    # Return types for this module. Result is an array of hashes, each of which
+    # describes a Puppet type. The type description hash structure is:
+    # * :name => Name of this Puppet type.
+    # * :doc => Documentation for this type.
+    # * :properties => Array of hashes representing the type's properties, each
+    #   containing :name and :doc.
+    # * :parameters => Array of hashes representing the type's parameters, each
+    #   containing :name and :doc.
+    # * :providers => Array of hashes representing the types providers, each
+    #   containing :name and :doc.
+    # TODO Write a TypeDescription to encapsulate these structures and logic?
+    def data
+      unless @data
+        @data = []
+        type_names = []
+        for module_filename in Dir[File.join(@module_path, "lib/puppet/type/*.rb")]
+          require module_filename
+          type_name = File.basename(module_filename, ".rb")
+          type_names << type_name
+
+          for provider_filename in Dir[File.join(@module_path, "lib/puppet/provider/#{type_name}/*.rb")]
+            require provider_filename
+          end
+        end
+
+        type_names.each do |type_name|
+          if type = Puppet::Type.type(type_name.to_sym)
+            type_hash = {:name => type_name, :doc => type.doc}
+            type_hash[:properties] = attr_doc(type, :property)
+            type_hash[:parameters] = attr_doc(type, :param)
+            if type.providers.size > 0
+              type_hash[:providers] = provider_doc(type)
+            end
+            @data << type_hash
+          else
+            Puppet.warning "Could not find/load type: #{type_name}"
+          end
+        end
+      end
+      @data
+    end
+
+    # Return an array of hashes representing this +type+'s attrs of +kind+
+    # (e.g. :param or :property), each containing :name and :doc.
+    def attr_doc(type, kind)
+      [].tap do |attrs|
+        type.allattrs.each do |name|
+          if type.attrtype(name) == kind && name != :provider
+            attrs.push(:name => name, :doc => type.attrclass(name).doc)
+          end
+        end
+      end
+    end
+
+    # Return an array of hashes representing this +type+'s providers, each
+    # containing :name and :doc.
+    def provider_doc(type)
+      [].tap do |providers|
+        type.providers.sort_by{ |o| o.to_s }.each do |prov|
+          providers.push(:name => prov, :doc => type.provider(prov).doc)
+        end
+      end
+    end
+  end
+end

data/lib/puppet/module_tool/dependency.rb

@@ -0,0 +1,24 @@
+module Puppet::Module::Tool
+
+  class Dependency
+
+    # Instantiates a new module dependency with a +full_module_name+ (e.g.
+    # "myuser-mymodule"), and optional +version_requirement+ (e.g. "0.0.1") and
+    # optional repository (a URL string).
+    def initialize(full_module_name, version_requirement = nil, repository = nil)
+      @full_module_name = full_module_name
+      # TODO: add error checking, the next line raises ArgumentError when +full_module_name+ is invalid
+      @username, @name = Puppet::Module::Tool.username_and_modname_from(full_module_name)
+      @version_requirement = version_requirement
+      @repository = repository ? Repository.new(repository) : nil
+    end
+
+    # Return PSON representation of this data.
+    def to_pson(*args)
+      result = { :name => @full_module_name }
+      result[:version_requirement] = @version_requirement if @version_requirement && ! @version_requirement.nil?
+      result[:repository] = @repository.to_s if @repository && ! @repository.nil?
+      result.to_pson(*args)
+    end
+  end
+end

data/lib/puppet/module_tool/metadata.rb

@@ -0,0 +1,141 @@
+module Puppet::Module::Tool
+
+  # = Metadata
+  #
+  # This class provides a data structure representing a module's metadata.
+  # It provides some basic parsing, but other data is injected into it using
+  # +annotate+ methods in other classes.
+  class Metadata
+
+    # The full name of the module, which is a dash-separated combination of the
+    # +username+ and module +name+.
+    attr_reader :full_module_name
+
+    # The name of the user that owns this module.
+    attr_reader :username
+
+    # The name of this module. See also +full_module_name+.
+    attr_reader :name
+
+    # The version of this module.
+    attr_reader :version
+
+    # Instantiate from a hash, whose keys are setters in this class.
+    def initialize(settings={})
+      settings.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    # Set the full name of this module, and from it, the +username+ and
+    # module +name+.
+    def full_module_name=(full_module_name)
+      @full_module_name = full_module_name
+      @username, @name = Puppet::Module::Tool::username_and_modname_from(full_module_name)
+    end
+
+    # Return an array of the module's Dependency objects.
+    def dependencies
+      return @dependencies ||= []
+    end
+
+    def author
+      @author || @username
+    end
+
+    def author=(author)
+      @author = author
+    end
+
+    def source
+      @source || 'UNKNOWN'
+    end
+
+    def source=(source)
+      @source = source
+    end
+
+    def license
+      @license || 'Apache License, Version 2.0'
+    end
+
+    def license=(license)
+      @license = license
+    end
+
+    def summary
+      @summary || 'UNKNOWN'
+    end
+
+    def summary=(summary)
+      @summary = summary
+    end
+
+    def description
+      @description || 'UNKNOWN'
+    end
+
+    def description=(description)
+      @description = description
+    end
+
+    def project_page
+      @project_page || 'UNKNOWN'
+    end
+
+    def project_page=(project_page)
+      @project_page = project_page
+    end
+
+    # Return an array of the module's Puppet types, each one is a hash
+    # containing :name and :doc.
+    def types
+      return @types ||= []
+    end
+
+    # Return module's file checksums.
+    def checksums
+      return @checksums ||= {}
+    end
+
+    # Return the dashed name of the module, which may either be the
+    # dash-separated combination of the +username+ and module +name+, or just
+    # the module +name+.
+    def dashed_name
+      return [@username, @name].compact.join('-')
+    end
+
+    # Return the release name, which is the combination of the +dashed_name+
+    # of the module and its +version+ number.
+    def release_name
+      return [dashed_name, @version].join('-')
+    end
+
+    # Set the version of this module, ensure a string like '0.1.0' see the
+    # Semantic Versions here: http://semver.org
+    def version=(version)
+      if SemVer.valid?(version)
+        @version = version
+      else
+        raise ArgumentError, "Invalid version format: #{@version} (Semantic Versions are acceptable: http://semver.org)"
+      end
+    end
+
+    # Return the PSON record representing this instance.
+    def to_pson(*args)
+      return {
+        :name         => @full_module_name,
+        :version      => @version,
+        :source       => source,
+        :author       => author,
+        :license      => license,
+        :summary      => summary,
+        :description  => description,
+        :project_page => project_page,
+        :dependencies => dependencies,
+        :types        => types,
+        :checksums    => checksums
+      }.to_pson(*args)
+    end
+  end
+end

data/lib/puppet/module_tool/modulefile.rb

@@ -0,0 +1,75 @@
+module Puppet::Module::Tool
+
+  # = Modulefile
+  #
+  # This class provides the DSL used for evaluating the module's 'Modulefile'.
+  # These methods are used to concisely define this module's attributes, which
+  # are later rendered as PSON into a 'metadata.json' file.
+  class ModulefileReader
+
+    # Read the +filename+ and eval its Ruby code to set values in the Metadata
+    # +metadata+ instance.
+    def self.evaluate(metadata, filename)
+      returning(new(metadata)) do |builder|
+        if File.file?(filename)
+          builder.instance_eval(File.read(filename.to_s), filename.to_s, 1)
+        else
+          Puppet.warning "No Modulefile: #{filename}"
+        end
+      end
+    end
+
+    # Instantiate with the Metadata +metadata+ instance.
+    def initialize(metadata)
+      @metadata = metadata
+    end
+
+    # Set the +full_module_name+ (e.g. "myuser-mymodule"), which will also set the
+    # +username+ and module +name+. Required.
+    def name(name)
+      @metadata.full_module_name = name
+    end
+
+    # Set the module +version+ (e.g., "0.0.1"). Required.
+    def version(version)
+      @metadata.version = version
+    end
+
+    # Add a dependency with the full_module_name +name+ (e.g. "myuser-mymodule"), an
+    # optional +version_requirement+ (e.g. "0.0.1") and +repository+ (a URL
+    # string). Optional. Can be called multiple times to add many dependencies.
+    def dependency(name, version_requirement = nil, repository = nil)
+      @metadata.dependencies << Dependency.new(name, version_requirement, repository)
+    end
+
+    # Set the source
+    def source(source)
+      @metadata.source = source
+    end
+
+    # Set the author or default to +username+
+    def author(author)
+        @metadata.author = author
+    end
+
+    # Set the license
+    def license(license)
+      @metadata.license = license
+    end
+
+   # Set the summary
+   def summary(summary)
+      @metadata.summary = summary
+    end
+
+   # Set the description
+   def description(description)
+      @metadata.description = description
+   end
+
+   # Set the project page
+   def project_page(project_page)
+      @metadata.project_page = project_page
+    end
+  end
+end

data/lib/puppet/module_tool/repository.rb

@@ -0,0 +1,79 @@
+require 'net/http'
+require 'digest/sha1'
+require 'uri'
+
+module Puppet::Module::Tool
+
+  # = Repository
+  #
+  # This class is a file for accessing remote repositories with modules.
+  class Repository
+    include Utils::Interrogation
+
+    attr_reader :uri, :cache
+
+    # Instantiate a new repository instance rooted at the optional string
+    # +url+, else an instance of the default Puppet modules repository.
+    def initialize(url=Puppet[:module_repository])
+      @uri = url.is_a?(::URI) ? url : ::URI.parse(url)
+      @cache = Cache.new(self)
+    end
+
+    # Return a Net::HTTPResponse read for this +request+.
+    #
+    # Options:
+    # * :authenticate => Request authentication on the terminal. Defaults to false.
+    def make_http_request(request, options = {})
+      if options[:authenticate]
+        authenticate(request)
+      end
+      if ! @uri.user.nil? && ! @uri.password.nil?
+        request.basic_auth(@uri.user, @uri.password)
+      end
+      return read_response(request)
+    end
+
+    # Return a Net::HTTPResponse read from this HTTPRequest +request+.
+    def read_response(request)
+      begin
+        Net::HTTP::Proxy(
+            Puppet::Module::Tool::http_proxy_host,
+            Puppet::Module::Tool::http_proxy_port
+            ).start(@uri.host, @uri.port) do |http|
+          http.request(request)
+        end
+      rescue Errno::ECONNREFUSED, SocketError
+        raise RuntimeError, "Could not reach remote repository"
+      end
+    end
+
+    # Set the HTTP Basic Authentication parameters for the Net::HTTPRequest
+    # +request+ by asking the user for input on the console.
+    def authenticate(request)
+      Puppet.notice "Authenticating for #{@uri}"
+      email = prompt('Email Address')
+      password = prompt('Password', true)
+      request.basic_auth(email, password)
+    end
+
+    # Return the local file name containing the data downloaded from the
+    # repository at +release+ (e.g. "myuser-mymodule").
+    def retrieve(release)
+      return cache.retrieve(@uri + release)
+    end
+
+    # Return the URI string for this repository.
+    def to_s
+      return @uri.to_s
+    end
+
+    # Return the cache key for this repository, this a hashed string based on
+    # the URI.
+    def cache_key
+      return @cache_key ||= [
+        @uri.to_s.gsub(/[^[:alnum:]]+/, '_').sub(/_$/, ''),
+        Digest::SHA1.hexdigest(@uri.to_s)
+      ].join('-')
+    end
+  end
+end