class Stove::Cli

Public Class Methods

new(argv, stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel) click to toggle source
# File lib/stove/cli.rb, line 6
def initialize(argv, stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel)
  @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
end

Public Instance Methods

execute!() click to toggle source
# File lib/stove/cli.rb, line 10
def execute!
  $stdout, $stderr = @stdout, @stderr

  # Parse the options hash
  option_parser.parse!(@argv)

  # Login command
  if @argv.first == 'login'
    if options[:username].nil? || options[:username].to_s.strip.empty?
      raise "Missing argument `--username'!"
    end

    if options[:key].nil? || options[:key].to_s.strip.empty?
      raise "Missing argument `--key'!"
    end

    Config.username = options[:username]
    Config.key      = options[:key]
    Config.endpoint = options[:endpoint] unless options[:endpoint].nil?
    Config.save

    @stdout.puts "Successfully saved config to `#{Config.__path__}'!"
    @kernel.exit(0)
    return
  end

  # Override configs
  Config.endpoint        = options[:endpoint]        if options[:endpoint]
  Config.username        = options[:username]        if options[:username]
  Config.key             = options[:key]             if options[:key]
  Config.artifactory     = options[:artifactory]     if options[:artifactory]
  Config.artifactory_key = options[:artifactory_key] if options[:artifactory_key]
  Config.ssl_verify      = options[:ssl_verify]

  # Set the log level
  Stove.log_level = options[:log_level]

  # Useful debugging output for when people type the wrong fucking command
  # and then open an issue like it's somehow my fault
  Stove::Log.info("Options: #{options.inspect}")
  Stove::Log.info("ARGV: #{@argv.inspect}")

  # Make a new cookbook object - this will raise an exception if there is
  # no cookbook at the given path
  cookbook = Cookbook.new(options[:path])

  # Now execute the actual runners (validations and errors might occur)
  runner = Runner.new(cookbook, options)
  runner.run

  # If we got this far, everything was successful :)
  @kernel.exit(0)
rescue => e
  Stove::Log.init($stderr)
  Stove::Log.error('Stove experienced an error!')
  Stove::Log.error(e.class.name)
  Stove::Log.error(e.message)
  Stove::Log.error(e.backtrace.join("\n"))

  @kernel.exit(e.respond_to?(:exit_code) ? e.exit_code : 500)
ensure
  $stdout, $stderr = STDOUT, STDERR
end

Private Instance Methods

option_parser() click to toggle source

The option parser for handling command line flags.

@return [OptionParser]

# File lib/stove/cli.rb, line 81
def option_parser
  @option_parser ||= OptionParser.new do |opts|
    opts.banner = 'Usage: stove [OPTIONS]'

    opts.separator ''
    opts.separator 'Plugins:'

    opts.on('--no-git', 'Do not use the git plugin. Skips tagging if specified.') do
      options[:no_git] = true
    end

    opts.separator ''
    opts.separator 'Upload Options:'

    opts.on('--endpoint [URL]', 'Supermarket endpoint') do |v|
      options[:endpoint] = v
    end

    opts.on('--username [USERNAME]', 'Username to authenticate with') do |v|
      options[:username] = v
    end

    opts.on('--key [PATH]', 'Path to the private key on disk') do |v|
      options[:key] = v
    end

    opts.on('--[no-]extended-metadata', 'Include non-backwards compatible metadata keys such as `issues_url`') do |v|
      options[:extended_metadata] = v
    end

    opts.on('--no-ssl-verify', 'Turn off ssl verify') do
      options[:ssl_verify] = false
    end

    opts.separator ''
    opts.separator 'Git Options:'

    opts.on('--remote [REMOTE]', 'Name of the git remote') do |v|
      options[:remote] = v
    end

    opts.on('--branch [BRANCH]', 'Name of the git branch') do |v|
      options[:branch] = v
    end

    opts.on('--sign', 'Sign git tags') do
      options[:sign] = true
    end

    opts.separator ''
    opts.separator 'Artifactory Options:'

    opts.on('--artifactory [URL]', 'URL for the Artifactory repository') do |v|
      options[:artifactory] = v
    end

    opts.on('--artifactory-key [KEY]', 'Artifactory API key to use') do |v|
      options[:artifactory_key] = if v[0] == '@'
        # If passed a key looking like @foo, read it as a file. This allows
        # passing in the key securely.
        IO.read(File.expand_path(v[1..-1]))
      else
        v
      end
    end

    opts.separator ''
    opts.separator 'Global Options:'

    opts.on('--log-level [LEVEL]', 'Set the log verbosity') do |v|
      options[:log_level] = v
    end

    opts.on('--path [PATH]', 'Change the path to a cookbook') do |v|
      options[:path] = v
    end

    opts.on_tail('-h', '--help', 'Show this message') do
      puts opts
      exit
    end

    opts.on_tail('-v', '--version', 'Show version') do
      puts Stove::VERSION
      exit(0)
    end
  end
end
options() click to toggle source

The options to pass to the cookbook. Includes default values that are manipulated by the option parser.

@return [Hash]

# File lib/stove/cli.rb, line 174
def options
  @options ||= {
    # Upload options
    :endpoint          => nil,
    :username          => Config.username,
    :key               => Config.key,
    :extended_metadata => true,
    :ssl_verify        => true,

    # Git options
    :remote => 'origin',
    :branch => 'master',
    :sign   => false,

    # Artifactory options
    :artifactory     => false,
    :artifactory_key => ENV['ARTIFACTORY_API_KEY'],

    # Global options
    :log_level => :warn,
    :path      => Dir.pwd,
  }
end