puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/face/module/upgrade.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+Puppet::Face.define(:module, '1.0.0') do
+  action(:upgrade) do
+    summary "Upgrade a puppet module."
+    description <<-EOT
+      Upgrades a puppet module.
+    EOT
+
+    returns "Hash"
+
+    examples <<-EOT
+      upgrade an installed module to the latest version
+
+      $ puppet module upgrade puppetlabs-apache
+      /etc/puppet/modules
+      └── puppetlabs-apache (v1.0.0 -> v2.4.0)
+
+      upgrade an installed module to a specific version
+
+      $ puppet module upgrade puppetlabs-apache --version 2.1.0
+      /etc/puppet/modules
+      └── puppetlabs-apache (v1.0.0 -> v2.1.0)
+
+      upgrade an installed module for a specific environment
+
+      $ puppet module upgrade puppetlabs-apache --environment test
+      /usr/share/puppet/environments/test/modules
+      └── puppetlabs-apache (v1.0.0 -> v2.4.0)
+    EOT
+
+    arguments "<name>"
+
+    option "--force", "-f" do
+      summary "Force upgrade of an installed module."
+      description <<-EOT
+        Force the upgrade of an installed module even if there are local
+        changes or the possibility of causing broken dependencies.
+      EOT
+    end
+
+    option "--ignore-dependencies" do
+      summary "Do not attempt to install dependencies."
+      description <<-EOT
+        Do not attempt to install dependencies
+      EOT
+    end
+
+    option "--environment NAME" do
+      default_to { "production" }
+      summary "The target environment to search for modules."
+      description <<-EOT
+        The target environment to search for modules.
+      EOT
+    end
+
+    option "--version=" do
+      summary "The version of the module to upgrade to."
+      description <<-EOT
+        The version of the module to upgrade to.
+      EOT
+    end
+
+    when_invoked do |name, options|
+      name = name.gsub('/', '-')
+      Puppet.notice "Preparing to upgrade '#{name}' ..."
+      Puppet::ModuleTool::Applications::Upgrader.new(name, options).run
+    end
+
+    when_rendering :console do |return_value|
+      if return_value[:result] == :failure
+        Puppet.err(return_value[:error][:multiline])
+        exit 1
+      elsif return_value[:result] == :noop
+        Puppet.err(return_value[:error][:multiline])
+        exit 0
+      else
+        tree = Puppet::ModuleTool.build_tree(return_value[:affected_modules], return_value[:base_dir])
+        return_value[:base_dir] + "\n" +
+        Puppet::ModuleTool.format_tree(tree)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'puppet/face'
+require 'puppet/module_tool'
+require 'puppet/util/colors'
+
+Puppet::Face.define(:module, '1.0.0') do
+  extend Puppet::Util::Colors
+
+  copyright "Puppet Labs", 2012
+  license   "Apache 2 license; see COPYING"
+
+  summary "Creates, installs and searches for modules on the Puppet Forge."
+  description <<-EOT
+    This subcommand can find, install, and manage modules from the Puppet Forge,
+    a repository of user-contributed Puppet code. It can also generate empty
+    modules, and prepare locally developed modules for release on the Forge.
+  EOT
+end

data/lib/vendor/puppet/face/node/clean.rb

@@ -0,0 +1,156 @@
+Puppet::Face.define(:node, '0.0.1') do
+  action(:clean) do
+    option "--[no-]unexport" do
+      summary "Whether to remove this node's exported resources from other nodes"
+    end
+
+    summary "Clean up everything a puppetmaster knows about a node."
+    arguments "<host1> [<host2> ...]"
+    description <<-'EOT'
+      Clean up everything a puppet master knows about a node, including certificates
+      and storeconfigs data.
+      
+      The full list of info cleaned by this action is:
+
+      <Signed certificates> - ($vardir/ssl/ca/signed/node.domain.pem)
+      
+      <Cached facts> - ($vardir/yaml/facts/node.domain.yaml)
+      
+      <Cached node objects> - ($vardir/yaml/node/node.domain.yaml)
+      
+      <Reports> - ($vardir/reports/node.domain)
+      
+      <Stored configs> - (in database) The clean action can either remove all
+      data from a host in your storeconfigs database, or, with the
+      <--unexport> option, turn every exported resource supporting ensure to
+      absent so that any other host that collected those resources can remove
+      them. Without unexporting, a removed node's exported resources become
+      unmanaged by Puppet, and may linger as cruft unless you are purging
+      that resource type.
+    EOT
+
+    when_invoked do |*args|
+      nodes = args[0..-2]
+      options = args.last
+      raise "At least one node should be passed" if nodes.empty? || nodes == options
+
+      # TODO: this is a hack and should be removed if faces provide the proper
+      # infrastructure to set the run mode.
+      require 'puppet/util/run_mode'
+      $puppet_application_mode = Puppet::Util::RunMode[:master]
+
+      if Puppet::SSL::CertificateAuthority.ca?
+        Puppet::SSL::Host.ca_location = :local
+      else
+        Puppet::SSL::Host.ca_location = :none
+      end
+
+      Puppet::Node::Facts.indirection.terminus_class = :yaml
+      Puppet::Node::Facts.indirection.cache_class = :yaml
+      Puppet::Node.indirection.terminus_class = :yaml
+      Puppet::Node.indirection.cache_class = :yaml
+
+      nodes.each { |node| cleanup(node.downcase, options[:unexport]) }
+    end
+  end
+
+  def cleanup(node, unexport)
+    clean_cert(node)
+    clean_cached_facts(node)
+    clean_cached_node(node)
+    clean_reports(node)
+    clean_storeconfigs(node, unexport)
+  end
+
+  # clean signed cert for +host+
+  def clean_cert(node)
+    if Puppet::SSL::CertificateAuthority.ca?
+      Puppet::Face[:ca, :current].revoke(node)
+      Puppet::Face[:ca, :current].destroy(node)
+      Puppet.info "#{node} certificates removed from ca"
+    else
+      Puppet.info "Not managing #{node} certs as this host is not a CA"
+    end
+  end
+
+  # clean facts for +host+
+  def clean_cached_facts(node)
+    Puppet::Node::Facts.indirection.destroy(node)
+    Puppet.info "#{node}'s facts removed"
+  end
+
+  # clean cached node +host+
+  def clean_cached_node(node)
+    Puppet::Node.indirection.destroy(node)
+    Puppet.info "#{node}'s cached node removed"
+  end
+
+  # clean node reports for +host+
+  def clean_reports(node)
+    Puppet::Transaction::Report.indirection.destroy(node)
+    Puppet.info "#{node}'s reports removed"
+  end
+
+  # clean storeconfig for +node+
+  def clean_storeconfigs(node, do_unexport=false)
+    return unless Puppet[:storeconfigs] && Puppet.features.rails?
+    require 'puppet/rails'
+    Puppet::Rails.connect
+    unless rails_node = Puppet::Rails::Host.find_by_name(node)
+      Puppet.notice "No entries found for #{node} in storedconfigs."
+      return
+    end
+
+    if do_unexport
+      unexport(rails_node)
+      Puppet.notice "Force #{node}'s exported resources to absent"
+      Puppet.warning "Please wait until all other hosts have checked out their configuration before finishing the cleanup with:"
+      Puppet.warning "$ puppet node clean #{node}"
+    else
+      rails_node.destroy
+      Puppet.notice "#{node} storeconfigs removed"
+    end
+  end
+
+  def unexport(node)
+    # fetch all exported resource
+    query = {:include => {:param_values => :param_name}}
+    query[:conditions] = [ "exported=? AND host_id=?", true, node.id ]
+    Puppet::Rails::Resource.find(:all, query).each do |resource|
+      if type_is_ensurable(resource)
+        line = 0
+        param_name = Puppet::Rails::ParamName.find_or_create_by_name("ensure")
+
+        if ensure_param = resource.param_values.find(
+          :first,
+          :conditions => [ 'param_name_id = ?', param_name.id ]
+        )
+          line = ensure_param.line.to_i
+          Puppet::Rails::ParamValue.delete(ensure_param.id);
+        end
+
+        # force ensure parameter to "absent"
+        resource.param_values.create(
+          :value => "absent",
+          :line => line,
+          :param_name => param_name
+        )
+        Puppet.info("#{resource.name} has been marked as \"absent\"")
+      end
+    end
+  end
+
+  def environment
+    @environment ||= Puppet::Node::Environment.new
+  end
+
+  def type_is_ensurable(resource)
+    if (type = Puppet::Type.type(resource.restype)) && type.validattr?(:ensure)
+      return true
+    else
+      type = environment.known_resource_types.find_definition('', resource.restype)
+      return true if type && type.arguments.keys.include?('ensure')
+    end
+    return false
+  end
+end

data/lib/vendor/puppet/face/node.rb

@@ -0,0 +1,43 @@
+require 'puppet/indirector/face'
+Puppet::Indirector::Face.define(:node, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "View and manage node definitions."
+  description <<-'EOT'
+    This subcommand interacts with node objects, which are used by Puppet to
+    build a catalog. A node object consists of the node's facts, environment,
+    node parameters (exposed in the parser as top-scope variables), and classes.
+  EOT
+
+  get_action(:destroy).summary "Invalid for this subcommand."
+  get_action(:search).summary "Invalid for this subcommand."
+  get_action(:save).summary "Invalid for this subcommand."
+  get_action(:save).description "Invalid for this subcommand."
+
+  find = get_action(:find)
+  find.summary "Retrieve a node object."
+  find.arguments "<host>"
+  find.returns <<-'EOT'
+    A hash containing the node's `classes`, `environment`, `expiration`, `name`,
+    `parameters` (its facts, combined with any ENC-set parameters), and `time`.
+    When used from the Ruby API: a Puppet::Node object.
+
+    RENDERING ISSUES: Rendering as string and json are currently broken;
+    node objects can only be rendered as yaml.
+  EOT
+  find.examples <<-'EOT'
+    Retrieve an "empty" (no classes, no ENC-imposed parameters, and an
+    environment of "production") node:
+
+    $ puppet node find somenode.puppetlabs.lan --terminus plain --render-as yaml
+
+    Retrieve a node using the puppet master's configured ENC:
+
+    $ puppet node find somenode.puppetlabs.lan --terminus exec --mode master --render-as yaml
+
+    Retrieve the same node from the puppet master:
+
+    $ puppet node find somenode.puppetlabs.lan --terminus rest --render-as yaml
+  EOT
+end

data/lib/vendor/puppet/face/parser.rb

@@ -0,0 +1,51 @@
+require 'puppet/face'
+require 'puppet/parser'
+
+Puppet::Face.define(:parser, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "Interact directly with the parser."
+
+  action :validate do
+    summary "Validate the syntax of one or more Puppet manifests."
+    arguments "[<manifest>] [<manifest> ...]"
+    returns "Nothing, or the first syntax error encountered."
+    description <<-'EOT'
+      This action validates Puppet DSL syntax without compiling a catalog or
+      syncing any resources. If no manifest files are provided, it will
+      validate the default site manifest.
+    EOT
+    examples <<-'EOT'
+      Validate the default site manifest at /etc/puppet/manifests/site.pp:
+
+      $ puppet parser validate
+
+      Validate two arbitrary manifest files:
+
+      $ puppet parser validate init.pp vhost.pp
+
+      Validate from STDIN:
+
+      $ cat init.pp | puppet parser validate
+    EOT
+    when_invoked do |*args|
+      args.pop
+      files = args
+      if files.empty?
+        if not STDIN.tty?
+          Puppet[:code] = STDIN.read
+          Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types.clear
+        else
+           files << Puppet[:manifest]
+           Puppet.notice "No manifest specified. Validating the default manifest #{Puppet[:manifest]}"
+        end
+      end
+      files.each do |file|
+        Puppet[:manifest] = file
+        Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types.clear
+      end
+      nil
+    end
+  end
+end

data/lib/vendor/puppet/face/plugin.rb

@@ -0,0 +1,55 @@
+require 'puppet/face'
+Puppet::Face.define(:plugin, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "Interact with the Puppet plugin system."
+  description <<-'EOT'
+    This subcommand provides network access to the puppet master's store of
+    plugins.
+
+    The puppet master serves Ruby code collected from the `lib` directories
+    of its modules. These plugins can be used on agent nodes to extend
+    Facter and implement custom types and providers. Plugins are normally
+    downloaded by puppet agent during the course of a run.
+  EOT
+
+  action :download do
+    summary "Download plugins from the puppet master."
+    description <<-'EOT'
+      Downloads plugins from the configured puppet master. Any plugins
+      downloaded in this way will be used in all subsequent Puppet activity.
+      This action modifies files on disk.
+    EOT
+    returns <<-'EOT'
+      A list of the files downloaded, or a confirmation that no files were
+      downloaded. When used from the Ruby API, this action returns an array of
+      the files downloaded, which will be empty if none were retrieved.
+    EOT
+    examples <<-'EOT'
+      Retrieve plugins from the puppet master:
+
+      $ puppet plugin download
+
+      Retrieve plugins from the puppet master (API example):
+
+      $ Puppet::Face[:plugin, '0.0.1'].download
+    EOT
+
+    when_invoked do |options|
+      require 'puppet/configurer/downloader'
+      Puppet::Configurer::Downloader.new("plugin",
+                                         Puppet[:plugindest],
+                                         Puppet[:pluginsource],
+                                         Puppet[:pluginsignore]).evaluate
+    end
+
+    when_rendering :console do |value|
+      if value.empty? then
+        "No plugins downloaded."
+      else
+        "Downloaded these plugins: #{value.join(', ')}"
+      end
+    end
+  end
+end

data/lib/vendor/puppet/face/report.rb

@@ -0,0 +1,56 @@
+require 'puppet/indirector/face'
+
+Puppet::Indirector::Face.define(:report, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "Create, display, and submit reports."
+
+  get_action(:find).summary "Invalid for this face."
+  get_action(:search).summary "Invalid for this face."
+  get_action(:destroy).summary "Invalid for this face."
+  save = get_action(:save)
+  save.summary "API only: submit a report."
+  save.arguments "<report>"
+  save.returns "Nothing."
+  save.examples <<-'EOT'
+    From the implementation of `puppet report submit` (API example):
+
+        begin
+          Puppet::Transaction::Report.indirection.terminus_class = :rest
+          Puppet::Face[:report, "0.0.1"].save(report)
+          Puppet.notice "Uploaded report for #{report.name}"
+        rescue => detail
+          puts detail.backtrace if Puppet[:trace]
+          Puppet.err "Could not send report: #{detail}"
+        end
+  EOT
+
+  action(:submit) do
+    summary "API only: submit a report with error handling."
+    description <<-'EOT'
+      API only: Submits a report to the puppet master. This action is
+      essentially a shortcut and wrapper for the `save` action with the `rest`
+      terminus, and provides additional details in the event of a failure.
+    EOT
+    arguments "<report>"
+    examples <<-'EOT'
+      From secret_agent.rb (API example):
+
+          # ...
+          report  = Puppet::Face[:catalog, '0.0.1'].apply
+          Puppet::Face[:report, '0.0.1'].submit(report)
+          return report
+    EOT
+    when_invoked do |report, options|
+      begin
+        Puppet::Transaction::Report.indirection.terminus_class = :rest
+        Puppet::Face[:report, "0.0.1"].save(report)
+        Puppet.notice "Uploaded report for #{report.name}"
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Could not send report: #{detail}"
+      end
+    end
+  end
+end

data/lib/vendor/puppet/face/resource.rb

@@ -0,0 +1,53 @@
+require 'puppet/indirector/face'
+
+Puppet::Indirector::Face.define(:resource, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "API only: interact directly with resources via the RAL."
+  description <<-'EOT'
+    API only: this face provides a Ruby API with functionality similar to the
+    puppet resource (or ralsh) subcommand.
+  EOT
+
+  get_action(:destroy).summary "Invalid for this subcommand."
+
+  search = get_action(:search)
+  search.summary "API only: get all resources of a single type."
+  search.arguments "<resource_type>"
+  search.returns "An array of Puppet::Resource objects."
+  search.examples <<-'EOT'
+    Get a list of all user resources (API example):
+
+        all_users = Puppet::Face[:resource, '0.0.1'].search("user")
+  EOT
+
+  find = get_action(:find)
+  find.summary "API only: get a single resource."
+  find.arguments "<type>/<title>"
+  find.returns "A Puppet::Resource object."
+  find.examples <<-'EOT'
+    Print information about a user on this system (API example):
+
+        puts Puppet::Face[:resource, '0.0.1'].find("user/luke").to_pson
+  EOT
+
+  save = get_action(:save)
+  save.summary "API only: create a new resource."
+  save.description <<-EOT
+    API only: creates a new resource.
+  EOT
+  save.arguments "<resource_object>"
+  save.returns "The same resource object passed as an argument."
+  save.examples <<-'EOT'
+    Create a new file resource (API example):
+
+        my_resource = Puppet::Resource.new(
+          :file,
+          "/tmp/demonstration",
+          :parameters => {:ensure => :present, :content => "some\nthing\n"}
+        )
+
+        Puppet::Face[:resource, '0.0.1'].save(my_resource)
+  EOT
+end

data/lib/vendor/puppet/face/resource_type.rb

@@ -0,0 +1,81 @@
+require 'puppet/indirector/face'
+
+Puppet::Indirector::Face.define(:resource_type, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "View classes, defined resource types, and nodes from all manifests."
+  description <<-'EOT'
+    This subcommand reads information about the resource collections (classes,
+    nodes, and defined types) available in Puppet's site manifest and
+    modules.
+
+    It will eventually be extended to examine native resource types.
+  EOT
+  notes <<-'EOT'
+    The `find` and `search` actions return similar hashes of resource collection
+    info. These hashes will include the following four keys:
+
+    * `file` (a string)
+    * `name` (a string)
+    * `type` (<hostclass>, <definition>, or <node>)
+    * `line` (an integer)
+
+    They may optionally include the following keys:
+
+    * `parent`    (<name_of_resource_collection>)
+    * `arguments` (a hash of parameters and default values)
+    * `doc`       (a string)
+  EOT
+
+  # Action documentation overrides:
+  get_action(:save).summary = "Invalid for this subcommand."
+  get_action(:save).description "Invalid for this subcommand."
+  get_action(:destroy).summary = "Invalid for this subcommand."
+
+  find = get_action(:find)
+  find.summary "Retrieve info about a resource collection."
+  find.arguments "<collection_name>"
+  find.returns <<-'EOT'
+    A hash of info about the requested resource collection. When used from the
+    Ruby API: returns a Puppet::Resource::Type object.
+
+    RENDERING ISSUES: yaml and string output for this indirection are currently
+    unusable; use json instead.
+  EOT
+  find.notes <<-'EOT'
+    If two resource collections share the same name (e.g. you have both a node
+    and a class named "default"), `find` will only return one of them. This can
+    be worked around by using `search` instead.
+  EOT
+  find.examples <<-'EOT'
+    Retrieve info about a specific locally-defined class:
+
+    $ puppet resource_type find ntp::disabled
+
+    Retrieve info from the puppet master about a specific class:
+
+    $ puppet resource_type find ntp --terminus rest
+  EOT
+
+  search = get_action(:search)
+  search.summary "Search for collections matching a regular expression."
+  search.arguments "<regular_expression>"
+  search.returns <<-'EOT'
+    An array of hashes of resource collection info. When used from the Ruby API:
+    returns an array of Puppet::Resource::Type objects.
+
+    RENDERING ISSUES: yaml and string output for this indirection are currently
+    unusable; use json instead.
+  EOT
+  search.examples <<-'EOT'
+    Retrieve all classes, nodes, and defined types:
+
+    $ puppet resource_type search '.*'
+
+    Search for classes related to Nagios:
+
+    $ puppet resource_type search nagios
+  EOT
+
+end

data/lib/vendor/puppet/face/secret_agent.rb

@@ -0,0 +1,54 @@
+require 'puppet/face'
+
+Puppet::Face.define(:secret_agent, '0.0.1') do
+  copyright "Puppet Labs", 2011
+  license   "Apache 2 license; see COPYING"
+
+  summary "Mimics puppet agent."
+  description <<-'EOT'
+    This subcommand currently functions as a proof of concept, demonstrating how
+    the Faces API exposes Puppet's internal systems to application logic;
+    compare the actual code for puppet agent. It will eventually replace puppet
+    agent entirely, and can provide a template for users who wish to implement
+    agent-like functionality with non-standard application logic.
+  EOT
+
+  action(:synchronize) do
+    default
+    summary "Run secret_agent once."
+    description <<-'EOT'
+      Mimics a single run of puppet agent. This action does not currently
+      daemonize, but can download plugins, submit facts, retrieve and apply a
+      catalog, and submit a report to the puppet master.
+    EOT
+    returns <<-'EOT'
+      Verbose logging from the completed run. When used from the Ruby API:
+      returns a Puppet::Transaction::Report object.
+    EOT
+    examples <<-'EOT'
+      Trigger a Puppet run with the configured puppet master:
+
+      $ puppet secret_agent
+    EOT
+    notes <<-'EOT'
+      This action requires that the puppet master's `auth.conf` file allow save
+      access to the `facts` REST terminus. Puppet agent does not use this
+      facility, and it is turned off by default. See
+      <http://docs.puppetlabs.com/guides/rest_auth_conf.html> for more details.
+    EOT
+
+    when_invoked do |options|
+      Puppet::Face[:plugin, '0.0.1'].download
+
+      Puppet::Face[:facts, '0.0.1'].upload
+
+      Puppet::Face[:catalog, '0.0.1'].download
+
+      report  = Puppet::Face[:catalog, '0.0.1'].apply
+
+      Puppet::Face[:report, '0.0.1'].submit(report)
+
+      return report
+    end
+  end
+end