Class: Puppet::Application::Device

Inherits:

Puppet::Application

• Object
• Puppet::Application
• Puppet::Application::Device

Defined in:

lib/puppet/application/device.rb

Constant Summary

Constants inherited from Puppet::Application

DOCPATTERN

Constants included from Util

Util::AbsolutePathPosix, Util::AbsolutePathWindows, Util::DEFAULT_POSIX_MODE, Util::DEFAULT_WINDOWS_MODE

Constants included from Util::POSIX

Util::POSIX::LOCALE_ENV_VARS, Util::POSIX::USER_ENV_VARS

Constants included from Util::SymbolicFileMode

Util::SymbolicFileMode::SetGIDBit, Util::SymbolicFileMode::SetUIDBit, Util::SymbolicFileMode::StickyBit, Util::SymbolicFileMode::SymbolicMode, Util::SymbolicFileMode::SymbolicSpecialToBit

Instance Attribute Summary

• #agent ⇒ Object
• #args ⇒ Object
• #host ⇒ Object

Attributes inherited from Puppet::Application

#command_line, #options

Instance Method Summary

• #app_defaults ⇒ Object
• #help ⇒ Object
• #main ⇒ Object
• #preinit ⇒ Object
• #setup ⇒ Object
• #setup_host ⇒ Object

Methods inherited from Puppet::Application

[], available_application_names, banner, clear!, clear?, clear_everything_for_tests, #configure_indirector_routes, controlled_run, exit, find, #handle_logdest_arg, #handlearg, #initialize, #initialize_app_defaults, interrupted?, #log_runtime_environment, #name, option, option_parser_commands, #parse_options, restart!, restart_requested?, #run, #run_command, run_mode, #set_log_level, #setup_logs, stop!, stop_requested?, try_load_class

Methods included from Util

absolute_path?, benchmark, chuser, clear_environment, default_env, deterministic_rand, deterministic_rand_int, exit_on_fail, get_env, get_environment, logmethods, merge_environment, path_to_uri, pretty_backtrace, replace_file, safe_posix_fork, set_env, symbolizehash, thinmark, uri_to_path, which, withenv, withumask

Methods included from Util::POSIX

#get_posix_field, #gid, #idfield, #methodbyid, #methodbyname, #search_posix_field, #uid

Methods included from Util::SymbolicFileMode

#normalize_symbolic_mode, #symbolic_mode_to_int, #valid_symbolic_mode?

Constructor Details

This class inherits a constructor from Puppet::Application

Instance Attribute Details

#agent ⇒ Object

# File 'lib/puppet/application/device.rb', line 8

def agent
  @agent
end

#args ⇒ Object

# File 'lib/puppet/application/device.rb', line 8

def args
  @args
end

#host ⇒ Object

# File 'lib/puppet/application/device.rb', line 8

def host
  @host
end

Instance Method Details

#app_defaults ⇒ Object

# File 'lib/puppet/application/device.rb', line 10

def app_defaults
  super.merge({
    :catalog_terminus => :rest,
    :catalog_cache_terminus => :json,
    :node_terminus => :rest,
    :facts_terminus => :network_device,
  })
end

#help ⇒ Object

# File 'lib/puppet/application/device.rb', line 60

def help
  <<-'HELP'

puppet-device(8) -- Manage remote network devices
========

SYNOPSIS
--------
Retrieves all configurations from the puppet master and apply
them to the remote devices configured in /etc/puppetlabs/puppet/device.conf.

Currently must be run out periodically, using cron or something similar.

USAGE
-----
  puppet device [-d|--debug] [--detailed-exitcodes] [-V|--version]
            [-h|--help] [-l|--logdest syslog|<file>|console]
            [-v|--verbose] [-w|--waitforcert <seconds>]


DESCRIPTION
-----------
Once the client has a signed certificate for a given remote device, it will
retrieve its configuration and apply it.

USAGE NOTES
-----------
One need a /etc/puppetlabs/puppet/device.conf file with the following content:

[remote.device.fqdn]
type <type>
url <url>

where:
 * type: the current device type (the only value at this time is cisco)
 * url: an url allowing to connect to the device

Supported url must conforms to:
 scheme://user:password@hostname/?query

 with:
  * scheme: either ssh or telnet
  * user: username, can be omitted depending on the switch/router configuration
  * password: the connection password
  * query: this is device specific. Cisco devices supports an enable parameter whose
  value would be the enable password.

OPTIONS
-------
Note that any setting that's valid in the configuration file
is also a valid long argument.  For example, 'server' is a valid configuration
parameter, so you can specify '--server <servername>' as an argument.

* --debug:
  Enable full debugging.

* --detailed-exitcodes:
  Provide transaction information via exit codes. If this is enabled, an exit
  code of '1' means at least one device had a compile failure, an exit code of
  '2' means at least one device had resource changes, and an exit code of '4'
  means at least one device had resource failures. Exit codes of '3', '5', '6',
  or '7' means that a bitwise combination of the preceeding exit codes happened.

* --help:
  Print this help message

* --logdest:
  Where to send log messages. Choose between 'syslog' (the POSIX syslog
  service), 'console', or the path to a log file. If debugging or verbosity is
  enabled, this defaults to 'console'. Otherwise, it defaults to 'syslog'.

  A path ending with '.json' will receive structured output in JSON format. The
  log file will not have an ending ']' automatically written to it due to the
  appending nature of logging. It must be appended manually to make the content
  valid JSON.

* --verbose:
  Turn on verbose reporting.

* --waitforcert:
  This option only matters for daemons that do not yet have certificates
  and it is enabled by default, with a value of 120 (seconds).  This causes
  +puppet agent+ to connect to the server every 2 minutes and ask it to sign a
  certificate request.  This is useful for the initial setup of a puppet
  client.  You can turn off waiting for certificates by specifying a time
  of 0.

EXAMPLE
-------
  $ puppet device --server puppet.domain.com

AUTHOR
------
Brice Figureau


COPYRIGHT
---------
Copyright (c) 2011 Puppet Labs, LLC
Licensed under the Apache 2.0 License
  HELP
end

#main ⇒ Object

# File 'lib/puppet/application/device.rb', line 164

def main
  vardir = Puppet[:vardir]
  confdir = Puppet[:confdir]
  certname = Puppet[:certname]

  # find device list
  require 'puppet/util/network_device/config'
  devices = Puppet::Util::NetworkDevice::Config.devices
  if devices.empty?
    Puppet.err "No device found in #{Puppet[:deviceconfig]}"
    exit(1)
  end
  returns = devices.collect do |devicename,device|
    begin
      device_url = URI.parse(device.url)
      # Handle nil scheme & port
      scheme = "#{device_url.scheme}://" if device_url.scheme
      port = ":#{device_url.port}" if device_url.port
      Puppet.info "starting applying configuration to #{device.name} at #{scheme}#{device_url.host}#{port}#{device_url.path}"

      # override local $vardir and $certname
      Puppet[:confdir] = ::File.join(Puppet[:devicedir], device.name)
      Puppet[:vardir] = ::File.join(Puppet[:devicedir], device.name)
      Puppet[:certname] = device.name

      # this will reload and recompute default settings and create the devices sub vardir, or we hope so :-)
      Puppet.settings.use :main, :agent, :ssl

      # this init the device singleton, so that the facts terminus
      # and the various network_device provider can use it
      Puppet::Util::NetworkDevice.init(device)

      # ask for a ssl cert if needed, but at least
      # setup the ssl system for this device.
      setup_host

      require 'puppet/configurer'
      configurer = Puppet::Configurer.new
      configurer.run(:network_device => true, :pluginsync => Puppet::Configurer.should_pluginsync?)
    rescue => detail
      Puppet.log_exception(detail)
      # If we rescued an error, then we return 1 as the exit code
      1
    ensure
      Puppet[:vardir] = vardir
      Puppet[:confdir] = confdir
      Puppet[:certname] = certname
      Puppet::SSL::Host.reset
    end
  end
  if ! returns or returns.compact.empty?
    exit(1)
  elsif options[:detailed_exitcodes]
    # Bitwise OR the return codes together, puppet style
    exit(returns.compact.reduce(:|))
  elsif returns.include? 1
    exit(1)
  else
    exit(0)
  end
end

#preinit ⇒ Object

# File 'lib/puppet/application/device.rb', line 19

def preinit
  # Do an initial trap, so that cancels don't get a stack trace.
  Signal.trap(:INT) do
    $stderr.puts "Cancelling startup"
    exit(0)
  end

  {
    :waitforcert => nil,
    :detailed_exitcodes => false,
    :verbose => false,
    :debug => false,
    :centrallogs => false,
    :setdest => false,
  }.each do |opt,val|
    options[opt] = val
  end

  @args = {}
end

#setup ⇒ Object

# File 'lib/puppet/application/device.rb', line 232

def setup
  setup_logs

  args[:Server] = Puppet[:server]
  if options[:centrallogs]
    logdest = args[:Server]

    logdest += ":" + args[:Port] if args.include?(:Port)
    Puppet::Util::Log.newdestination(logdest)
  end

  Puppet.settings.use :main, :agent, :device, :ssl

  # We need to specify a ca location for all of the SSL-related
  # indirected classes to work; in fingerprint mode we just need
  # access to the local files and we don't need a ca.
  Puppet::SSL::Host.ca_location = :remote

  Puppet::Transaction::Report.indirection.terminus_class = :rest

  if Puppet[:catalog_cache_terminus]
    Puppet::Resource::Catalog.indirection.cache_class = Puppet[:catalog_cache_terminus].intern
  end
end

#setup_host ⇒ Object

# File 'lib/puppet/application/device.rb', line 226

def setup_host
  @host = Puppet::SSL::Host.new
  waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : Puppet[:waitforcert])
  @host.wait_for_cert(waitforcert)
end