puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/module_tool/shared_behaviors.rb

@@ -0,0 +1,161 @@
+module Puppet::ModuleTool::Shared
+
+  include Puppet::ModuleTool::Errors
+
+  def get_local_constraints
+    @local      = Hash.new { |h,k| h[k] = { } }
+    @conditions = Hash.new { |h,k| h[k] = [] }
+    @installed  = Hash.new { |h,k| h[k] = [] }
+
+    @environment.modules_by_path.values.flatten.each do |mod|
+      mod_name = (mod.forge_name || mod.name).gsub('/', '-')
+      @installed[mod_name] << mod
+      d = @local["#{mod_name}@#{mod.version}"]
+      (mod.dependencies || []).each do |hash|
+        name, conditions = hash['name'], hash['version_requirement']
+        name = name.gsub('/', '-')
+        d[name] = conditions
+        @conditions[name] << {
+          :module => mod_name,
+          :version => mod.version,
+          :dependency => conditions
+        }
+      end
+    end
+  end
+
+  def get_remote_constraints
+    @remote   = Hash.new { |h,k| h[k] = { } }
+    @urls     = {}
+    @versions = Hash.new { |h,k| h[k] = [] }
+
+    Puppet.notice "Downloading from #{Puppet::Forge.repository.uri} ..."
+    author, modname = Puppet::ModuleTool.username_and_modname_from(@module_name)
+    info = Puppet::Forge.remote_dependency_info(author, modname, @options[:version])
+    info.each do |pair|
+      mod_name, releases = pair
+      mod_name = mod_name.gsub('/', '-')
+      releases.each do |rel|
+        semver = SemVer.new(rel['version'] || '0.0.0') rescue SemVer.MIN
+        @versions[mod_name] << { :vstring => rel['version'], :semver => semver }
+        @versions[mod_name].sort! { |a, b| a[:semver] <=> b[:semver] }
+        @urls["#{mod_name}@#{rel['version']}"] = rel['file']
+        d = @remote["#{mod_name}@#{rel['version']}"]
+        (rel['dependencies'] || []).each do |name, conditions|
+          d[name.gsub('/', '-')] = conditions
+        end
+      end
+    end
+  end
+
+  def implicit_version(mod)
+    return :latest if @conditions[mod].empty?
+    if @conditions[mod].all? { |c| c[:queued] || c[:module] == :you }
+      return :latest
+    end
+    return :best
+  end
+
+  def annotated_version(mod, versions)
+    if versions.empty?
+      return implicit_version(mod)
+    else
+      return "#{implicit_version(mod)}: #{versions.last}"
+    end
+  end
+
+  def resolve_constraints(dependencies, source = [{:name => :you}], seen = {}, action = @action)
+    dependencies = dependencies.map do |mod, range|
+      source.last[:dependency] = range
+
+      @conditions[mod] << {
+        :module     => source.last[:name],
+        :version    => source.last[:version],
+        :dependency => range,
+        :queued     => true
+      }
+
+      if @force
+        range = SemVer[@version] rescue SemVer['>= 0.0.0']
+      else
+        range = (@conditions[mod]).map do |r|
+          SemVer[r[:dependency]] rescue SemVer['>= 0.0.0']
+        end.inject(&:&)
+      end
+
+      if @action == :install && seen.include?(mod)
+        next if range === seen[mod][:semver]
+
+        req_module   = @module_name
+        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        raise InvalidDependencyCycleError,
+          :module_name       => mod,
+          :source            => (source + [{ :name => mod, :version => source.last[:dependency] }]),
+          :requested_module  => req_module,
+          :requested_version => @version || annotated_version(req_module, req_versions),
+          :conditions        => @conditions
+      end
+
+      if !(@force || @installed[mod].empty? || source.last[:name] == :you)
+        next if range === SemVer.new(@installed[mod].first.version)
+        action = :upgrade
+      elsif @installed[mod].empty?
+        action = :install
+      end
+
+      if action == :upgrade
+        @conditions.each { |_, conds| conds.delete_if { |c| c[:module] == mod } }
+      end
+
+      valid_versions = @versions["#{mod}"].select { |h| range === h[:semver] }
+
+      unless version = valid_versions.last
+        req_module   = @module_name
+        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        raise NoVersionsSatisfyError,
+          :requested_name    => req_module,
+          :requested_version => @version || annotated_version(req_module, req_versions),
+          :installed_version => @installed[@module_name].empty? ? nil : @installed[@module_name].first.version,
+          :dependency_name   => mod,
+          :conditions        => @conditions[mod],
+          :action            => @action
+      end
+
+      seen[mod] = version
+
+      {
+        :module           => mod,
+        :version          => version,
+        :action           => action,
+        :previous_version => @installed[mod].empty? ? nil : @installed[mod].first.version,
+        :file             => @urls["#{mod}@#{version[:vstring]}"],
+        :path             => action == :install ? @options[:target_dir] : (@installed[mod].empty? ? @options[:target_dir] : @installed[mod].first.modulepath),
+        :dependencies     => []
+      }
+    end.compact
+    dependencies.each do |mod|
+      deps = @remote["#{mod[:module]}@#{mod[:version][:vstring]}"].sort_by(&:first)
+      mod[:dependencies] = resolve_constraints(deps, source + [{ :name => mod[:module], :version => mod[:version][:vstring] }], seen, :install)
+    end unless @ignore_dependencies
+    return dependencies
+  end
+
+  def download_tarballs(graph, default_path)
+    graph.map do |release|
+      begin
+        if release[:tarball]
+          cache_path = Pathname(release[:tarball])
+        else
+          cache_path = Puppet::Forge.repository.retrieve(release[:file])
+        end
+      rescue OpenURI::HTTPError => e
+        raise RuntimeError, "Could not download module: #{e.message}"
+      end
+
+      [
+        { (release[:path] ||= default_path) => cache_path},
+        *download_tarballs(release[:dependencies], default_path)
+      ]
+    end.flatten
+  end
+end

data/lib/vendor/puppet/module_tool/skeleton/templates/generator/Modulefile.erb

@@ -0,0 +1,11 @@
+name    '<%= metadata.full_module_name %>'
+version '0.0.1'
+source '<%= metadata.source %>'
+author '<%= metadata.author %>'
+license '<%= metadata.license %>'
+summary '<%= metadata.summary %>'
+description '<%= metadata.description %>'
+project_page '<%= metadata.project_page %>'
+
+## Add dependencies, if any:
+# dependency 'username/name', '>= 1.2.0'

data/lib/vendor/puppet/module_tool/skeleton/templates/generator/README.erb

@@ -0,0 +1,16 @@
+<%= metadata.name %>
+
+This is the <%= metadata.name %> module.
+
+License
+-------
+
+
+Contact
+-------
+
+
+Support
+-------
+
+Please log tickets and issues at our [Projects site](http://projects.example.com)

data/lib/vendor/puppet/module_tool/skeleton/templates/generator/manifests/init.pp.erb

@@ -0,0 +1,41 @@
+# == Class: <%= metadata.name %>
+#
+# Full description of class <%= metadata.name %> here.
+#
+# === Parameters
+#
+# Document parameters here.
+#
+# [*sample_parameter*]
+#   Explanation of what this parameter affects and what it defaults to.
+#   e.g. "Specify one or more upstream ntp servers as an array."
+#
+# === Variables
+#
+# Here you should define a list of variables that this module would require.
+#
+# [*sample_variable*]
+#   Explanation of how this variable affects the funtion of this class and if it
+#   has a default. e.g. "The parameter enc_ntp_servers must be set by the
+#   External Node Classifier as a comma separated list of hostnames." (Note,
+#   global variables should not be used in preference to class parameters  as of
+#   Puppet 2.6.)
+#
+# === Examples
+#
+#  class { <%= metadata.name %>:
+#    servers => [ 'pool.ntp.org', 'ntp.local.company.com' ]
+#  }
+#
+# === Authors
+#
+# Author Name <author@domain.com>
+#
+# === Copyright
+#
+# Copyright 2011 Your name here, unless otherwise noted.
+#
+class <%= metadata.name %> {
+
+
+}

data/lib/vendor/puppet/module_tool/skeleton/templates/generator/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+dir = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift File.join(dir, 'lib')
+
+require 'mocha'
+require 'puppet'
+require 'rspec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+    config.mock_with :mocha
+end
+
+# We need this because the RAL uses 'should' as a method.  This
+# allows us the same behaviour but with a different method name.
+class Object
+    alias :must :should
+end

data/lib/vendor/puppet/module_tool/skeleton/templates/generator/tests/init.pp.erb

@@ -0,0 +1,11 @@
+# The baseline for module testing used by Puppet Labs is that each manifest
+# should have a corresponding test manifest that declares that class or defined
+# type.
+#
+# Tests are then run by using puppet apply --noop (to check for compilation errors
+# and view a log of events) or by fully applying the test in a virtual environment
+# (to compare the resulting system state to the desired state).
+#
+# Learn more about module testing here: http://docs.puppetlabs.com/guides/tests_smoke.html
+#
+include <%= metadata.name %>

data/lib/vendor/puppet/module_tool/skeleton.rb

@@ -0,0 +1,34 @@
+module Puppet::ModuleTool
+
+  # = Skeleton
+  #
+  # This class provides methods for finding templates for the 'generate' action.
+  class Skeleton
+
+    # TODO Review whether the 'freeze' feature should be fixed or deleted.
+    # def freeze!
+    #   FileUtils.rm_fr custom_path rescue nil
+    #   FileUtils.cp_r default_path, custom_path
+    # end
+
+    # Return Pathname with 'generate' templates.
+    def path
+      paths.detect { |path| path.directory? }
+    end
+
+    # Return Pathnames to look for 'generate' templates.
+    def paths
+      @paths ||= [ custom_path, default_path ]
+    end
+
+    # Return Pathname of custom templates directory.
+    def custom_path
+      Pathname(Puppet.settings[:module_working_dir]) + 'skeleton'
+    end
+
+    # Return Pathname of default template directory.
+    def default_path
+      Pathname(__FILE__).dirname + 'skeleton/templates/generator'
+    end
+  end
+end

data/lib/vendor/puppet/module_tool.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+# Load standard libraries
+require 'pathname'
+require 'fileutils'
+require 'puppet/util/colors'
+
+# Define tool
+module Puppet
+  module ModuleTool
+    extend Puppet::Util::Colors
+
+    # Directory and names that should not be checksummed.
+    ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'metadata.json', 'REVISION']
+    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
+
+    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
+
+    # Builds a formatted tree from a list of node hashes containing +:text+
+    # and +:dependencies+ keys.
+    def self.format_tree(nodes, level = 0)
+      str = ''
+      nodes.each_with_index do |node, i|
+        last_node = nodes.length - 1 == i
+        deps = node[:dependencies] || []
+
+        str << (indent = "  " * level)
+        str << (last_node ? "└" : "├")
+        str << "─"
+        str << (deps.empty? ? "─" : "┬")
+        str << " #{node[:text]}\n"
+
+        branch = format_tree(deps, level + 1)
+        branch.gsub!(/^#{indent} /, indent + '│') unless last_node
+        str << branch
+      end
+
+      return str
+    end
+
+    def self.build_tree(mods, dir)
+      mods.each do |mod|
+        version_string = mod[:version][:vstring].sub(/^(?!v)/, 'v')
+
+        if mod[:action] == :upgrade
+          previous_version = mod[:previous_version].sub(/^(?!v)/, 'v')
+          version_string = "#{previous_version} -> #{version_string}"
+        end
+
+        mod[:text] = "#{mod[:module]} (#{colorize(:cyan, version_string)})"
+        mod[:text] += " [#{mod[:path]}]" unless mod[:path] == dir
+        build_tree(mod[:dependencies], dir)
+      end
+    end
+  end
+end
+
+# Load remaining libraries
+require 'puppet/module_tool/errors'
+require 'puppet/module_tool/applications'
+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/skeleton'
+require 'puppet/forge/cache'
+require 'puppet/forge'

data/lib/vendor/puppet/network/authconfig.rb

@@ -0,0 +1,174 @@
+require 'puppet/util/loadedfile'
+require 'puppet/network/rights'
+
+module Puppet
+  class ConfigurationError < Puppet::Error; end
+  class Network::AuthConfig < Puppet::Util::LoadedFile
+
+    def self.main
+      @main ||= self.new
+    end
+
+    # Just proxy the setting methods to our rights stuff
+    [:allow, :deny].each do |method|
+      define_method(method) do |*args|
+        @rights.send(method, *args)
+      end
+    end
+
+    # Here we add a little bit of semantics.  They can set auth on a whole
+    # namespace or on just a single method in the namespace.
+    def allowed?(request)
+      name        = request.call.intern
+      namespace   = request.handler.intern
+      method      = request.method.intern
+
+      read
+
+      if @rights.include?(name)
+        return @rights[name].allowed?(request.name, request.ip)
+      elsif @rights.include?(namespace)
+        return @rights[namespace].allowed?(request.name, request.ip)
+      end
+      false
+    end
+
+    # Does the file exist?  Puppetmasterd does not require it, but
+    # puppet agent does.
+    def exists?
+      FileTest.exists?(@file)
+    end
+
+    def initialize(file = nil, parsenow = true)
+      @file = file || Puppet[:authconfig]
+
+      raise Puppet::DevError, "No authconfig file defined" unless @file
+      return unless self.exists?
+      super(@file)
+      @rights = Puppet::Network::Rights.new
+      @configstamp = @configstatted = nil
+      @configtimeout = 60
+
+      read if parsenow
+    end
+
+    # Read the configuration file.
+    def read
+      return unless FileTest.exists?(@file)
+
+      if @configstamp
+        if @configtimeout and @configstatted
+          if Time.now - @configstatted > @configtimeout
+            @configstatted = Time.now
+            tmp = File.stat(@file).ctime
+
+            if tmp == @configstamp
+              return
+            else
+              Puppet.notice "#{tmp} vs #{@configstamp}"
+            end
+          else
+            return
+          end
+        else
+          Puppet.notice "#{@configtimeout} and #{@configstatted}"
+        end
+      end
+
+      parse
+
+      @configstamp = File.stat(@file).ctime
+      @configstatted = Time.now
+    end
+
+    private
+
+    def parse
+      newrights = Puppet::Network::Rights.new
+      begin
+        File.open(@file) { |f|
+          right = nil
+          count = 1
+          f.each_line { |line|
+            case line
+            when /^\s*#/ # skip comments
+              count += 1
+              next
+            when /^\s*$/  # skip blank lines
+              count += 1
+              next
+            when /^(?:(\[[\w.]+\])|(path)\s+((?:~\s+)?[^ ]+))\s*$/ # "namespace" or "namespace.method" or "path /path" or "path ~ regex"
+              name = $1
+              name = $3 if $2 == "path"
+              name.chomp!
+              right = newrights.newright(name, count, @file)
+            when /^\s*(allow|deny|method|environment|auth(?:enticated)?)\s+(.+?)(\s*#.*)?$/
+              parse_right_directive(right, $1, $2, count)
+            else
+              raise ConfigurationError, "Invalid line #{count}: #{line}"
+            end
+            count += 1
+          }
+        }
+      rescue Errno::EACCES => detail
+        Puppet.err "Configuration error: Cannot read #{@file}; cannot serve"
+        #raise Puppet::Error, "Cannot read #{@config}"
+      rescue Errno::ENOENT => detail
+        Puppet.err "Configuration error: '#{@file}' does not exit; cannot serve"
+        #raise Puppet::Error, "#{@config} does not exit"
+      #rescue FileServerError => detail
+      #    Puppet.err "FileServer error: #{detail}"
+      end
+
+      # Verify each of the rights are valid.
+      # We let the check raise an error, so that it can raise an error
+      # pointing to the specific problem.
+      newrights.each { |name, right|
+        right.valid?
+      }
+      @rights = newrights
+    end
+
+    def parse_right_directive(right, var, value, count)
+      value.strip!
+      case var
+      when "allow"
+        modify_right(right, :allow, value, "allowing %s access", count)
+      when "deny"
+        modify_right(right, :deny, value, "denying %s access", count)
+      when "method"
+        unless right.acl_type == :regex
+          raise ConfigurationError, "'method' directive not allowed in namespace ACL at line #{count} of #{@config}"
+        end
+        modify_right(right, :restrict_method, value, "allowing 'method' %s", count)
+      when "environment"
+        unless right.acl_type == :regex
+          raise ConfigurationError, "'environment' directive not allowed in namespace ACL at line #{count} of #{@config}"
+        end
+        modify_right(right, :restrict_environment, value, "adding environment %s", count)
+      when /auth(?:enticated)?/
+        unless right.acl_type == :regex
+          raise ConfigurationError, "'authenticated' directive not allowed in namespace ACL at line #{count} of #{@config}"
+        end
+        modify_right(right, :restrict_authenticated, value, "adding authentication %s", count)
+      else
+        raise ConfigurationError,
+          "Invalid argument '#{var}' at line #{count}"
+      end
+    end
+
+    def modify_right(right, method, value, msg, count)
+      value.split(/\s*,\s*/).each do |val|
+        begin
+          val.strip!
+          right.info msg % val
+          right.send(method, val)
+        rescue AuthStoreError => detail
+          raise ConfigurationError, "#{detail} at line #{count} of #{@file}"
+        end
+      end
+    end
+
+  end
+end
+

data/lib/vendor/puppet/network/authorization.rb

@@ -0,0 +1,76 @@
+require 'puppet/network/client_request'
+require 'puppet/network/authconfig'
+
+module Puppet::Network
+  # Most of our subclassing is just so that we can get
+  # access to information from the request object, like
+  # the client name and IP address.
+  class InvalidClientRequest < Puppet::Error; end
+  module Authorization
+    # Create our config object if necessary.  This works even if
+    # there's no configuration file.
+    def authconfig
+      @authconfig ||= Puppet::Network::AuthConfig.main
+
+      @authconfig
+    end
+
+    # Verify that our client has access.  We allow untrusted access to
+    # puppetca methods but no others.
+    def authorized?(request)
+      msg = "#{request.authenticated? ? "authenticated" : "unauthenticated"} client #{request} access to #{request.call}"
+
+      if request.authenticated?
+        if authconfig.exists?
+          if authconfig.allowed?(request)
+            Puppet.debug "Allowing #{msg}"
+            return true
+          else
+            Puppet.notice "Denying #{msg}"
+            return false
+          end
+        else
+          if Puppet.run_mode.master?
+            Puppet.debug "Allowing #{msg}"
+            return true
+          else
+            Puppet.notice "Denying #{msg}"
+            return false
+          end
+        end
+      else
+        if request.handler == "puppetca"
+          Puppet.notice "Allowing #{msg}"
+        else
+          Puppet.notice "Denying #{msg}"
+          return false
+        end
+      end
+    end
+
+    # Is this functionality available?
+    def available?(request)
+      if handler_loaded?(request.handler)
+        return true
+      else
+        Puppet.warning "Client #{request} requested unavailable functionality #{request.handler}"
+        return false
+      end
+    end
+
+    # Make sure that this method is available and authorized.
+    def verify(request)
+      unless available?(request)
+        raise InvalidClientRequest.new(
+          "Functionality #{request.handler} not available"
+        )
+      end
+      unless authorized?(request)
+        raise InvalidClientRequest.new(
+          "Host #{request} not authorized to call #{request.call}"
+        )
+      end
+    end
+  end
+end
+