moonshot 0.7.7 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a022cf1a54f893264b6ee7487303d79b8c29fb44
-  data.tar.gz: 7425456a02ec0451c431c6dc1863616fae9200e5
+  metadata.gz: 19e43423a8173b2f19405834ed09736d99a39b51
+  data.tar.gz: 4b344bc4416972f25320e35510e381aae44bfe7b
 SHA512:
-  metadata.gz: 8857003d9882c8fa70b559ba182887af90c5bd0b6cf2a62bc60e6bd4109c4e26e1f4ab6fd74bbc5764286cb592a1f70347659f0dfc79b8e13df104cc8356bc40
-  data.tar.gz: 36b9bb90372c8ae2bacf1253061d243c2333f57095fb49f2741de6d2bab602bfaed19652b2bcb86a22df67dc8e45af1ea583b0a760105dc8474c40a570dfa538
+  metadata.gz: 9807b9a1a23c3f395077ef83b5c950b43b0194fa1e981a1300381ef43a638f3950756ada942fb43b85105fc643d0232f939f2414ded42ee54dea30f5a5be6a83
+  data.tar.gz: 26bd43f893b325342bd7b6825b3045f0cbb88593efc1bc3916adb5751940ab70b116af6a5ef77a6a144869492048f2e5c4713d8694ab58d70bd8329a1b2f78d2

data/bin/moonshot

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require 'moonshot'
+
+# This is the main entry point for the `moonshot` command-line tool.
+begin
+  Moonshot::CommandLine.new.run!
+rescue => e
+  warn "#{e} (at #{e.backtrace.first})"
+  raise e if ENV['MOONSHOT_BACKTRACE']
+  exit 1
+end

data/lib/moonshot.rb

@@ -2,15 +2,25 @@ require 'English'
 require 'aws-sdk'
 require 'logger'
 require 'thor'
+require 'interactive-logger'
 
 module Moonshot
-  module ArtifactRepository # rubocop:disable Documentation
+  class << self
+    attr_writer :config
   end
-  module BuildMechanism # rubocop:disable Documentation
+
+  def self.config
+    @config ||= Moonshot::ControllerConfig.new
+    block_given? ? yield(@config) : @config
+  end
+
+  module ArtifactRepository
+  end
+  module BuildMechanism
   end
-  module DeploymentMechanism # rubocop:disable Documentation
+  module DeploymentMechanism
   end
-  module Plugins # rubocop:disable Documentation
+  module Plugins
   end
 end
 
@@ -20,17 +30,34 @@ end
   'doctor_helper',
   'resources',
   'resources_helper',
-  'environment_parser',
 
   # Core
   'interactive_logger_proxy',
+  'command_line',
+  'command',
+  'ssh_command',
+  'commands/build',
+  'commands/console',
+  'commands/create',
+  'commands/delete',
+  'commands/deploy',
+  'commands/doctor',
+  'commands/list',
+  'commands/push',
+  'commands/ssh',
+  'commands/status',
+  'commands/update',
+  'commands/version',
   'controller',
   'controller_config',
-  'cli',
   'stack',
   'stack_config',
   'stack_lister',
   'stack_events_poller',
+  'merge_strategy',
+  'default_strategy',
+  'ask_user_source',
+  'always_use_default_source',
 
   # Built-in mechanisms
   'artifact_repository/s3_bucket',

data/lib/moonshot/always_use_default_source.rb

@@ -0,0 +1,17 @@
+module Moonshot
+  # The AlwaysUseDefaultSource will always use the previous value in
+  # the stack, or use the default value during stack creation. This is
+  # useful if plugins provide the value for a parameter, and we don't
+  # want to prompt the user for an override. Of course, overrides from
+  # answer files or command-line arguments will always apply.
+  class AlwaysUseDefaultSource
+    def get(sp)
+      unless sp.default?
+        raise "Parameter #{sp.name} does not have a default, cannot use AlwaysUseDefaultSource!"
+      end
+
+      # Don't do anything, the default will apply on create, and the
+      # previous value will be used on update.
+    end
+  end
+end

data/lib/moonshot/artifact_repository/s3_bucket_via_github_releases.rb

@@ -1,5 +1,6 @@
 require 'moonshot/artifact_repository/s3_bucket'
 require 'moonshot/shell'
+require 'digest'
 require 'securerandom'
 require 'semantic'
 require 'tmpdir'
@@ -7,7 +8,7 @@ require 'tmpdir'
 module Moonshot::ArtifactRepository
   # S3 Bucket repository backed by GitHub releases.
   # If a SemVer package isn't found in S3, it is copied from GitHub releases.
-  class S3BucketViaGithubReleases < S3Bucket
+  class S3BucketViaGithubReleases < S3Bucket # rubocop:disable ClassLength
     include Moonshot::BuildMechanism
     include Moonshot::Shell
 
@@ -57,6 +58,12 @@ module Moonshot::ArtifactRepository
     def attach_release_asset(version, file)
       # -m '' leaves message unchanged.
       cmd = "hub release edit #{version} -m '' --attach=#{file}"
+
+      # If there is a checksum file, attach it as well. We only support MD5
+      # since that's what S3 uses.
+      checksum_file = File.basename(file, '.tar.gz') + '.md5'
+      cmd += " --attach=#{checksum_file}" if File.exist?(checksum_file)
+
       sh_step(cmd)
     end
 
@@ -70,13 +77,143 @@ module Moonshot::ArtifactRepository
     def github_to_s3(version, s3_name)
       Dir.mktmpdir('github_to_s3', Dir.getwd) do |tmpdir|
         Dir.chdir(tmpdir) do
-          sh_out("hub release download #{version}")
-          file = Dir.glob("*#{version}*.tar.gz").fetch(0)
+          file = download_from_github(version)
           upload_to_s3(file, s3_name)
         end
       end
     end
 
+    # Uploads the file to s3 and verifies the checksum.
+    #
+    # @param file [String] File to be uploaded to s3.
+    # @param key [String] Name of the object to be created on s3.
+    # @raise [RuntimeError] If the file fails to upload correctly after 3
+    #                       attempts.
+    def upload_to_s3(file, key)
+      attempts = 0
+      begin
+        super
+
+        unless (checksum = checksum_file(file)).nil?
+          verify_s3_checksum(key, checksum, attempt: attempts)
+        end
+      rescue RuntimeError => e
+        unless (attempts += 1) > 3
+          # Wait 10 seconds before trying again.
+          sleep 10
+          retry
+        end
+
+        raise e
+      end
+    end
+
+    # Downloads the release build from github and verifies the checksum.
+    #
+    # @param version [String] Version to be downloaded
+    # @param [String] Build file downloaded.
+    # @raise [RuntimeError] If the file fails to download correctly after 3
+    #                       attempts.
+    def download_from_github(version)
+      attempts = 0
+      begin
+        # Make sure the directory is empty before downloading the release.
+        FileUtils.rm(Dir.glob('*'))
+
+        # Download the release and find the actual build file.
+        sh_out("hub release download #{version}")
+        file = Dir.glob("*#{version}*.tar.gz").fetch(0)
+
+        unless (checksum = checksum_file(file)).nil?
+          verify_download_checksum(file, checksum, attempt: attempts)
+        end
+      rescue RuntimeError => e
+        attempts += 1
+        retry unless attempts > 3
+        raise e
+      end
+
+      file
+    end
+
+    # Find the checksum file for a release, if there is one.
+    #
+    # @param build_file [String] Build file to get the checksum for.
+    # @return [String] Checksum file or nil.
+    def checksum_file(build_file)
+      basename = File.basename(build_file, '.tar.gz')
+      Dir.glob("#{basename}.md5").fetch(0, nil)
+    end
+
+    # Verifies the checksum for a file downloaded from github.
+    #
+    # @param build_file [String] Build file to verify.
+    # @param checksum_file [String] Checksum file to verify the build.
+    # @param attempt [Integer] The attempt for this verification.
+    def verify_download_checksum(build_file, checksum_file, attempt: 0)
+      expected = File.read(checksum_file)
+      actual = Digest::MD5.file(build_file).hexdigest
+      if actual != expected
+        log.error("GitHub fie #{build_file} checksum should be #{expected} " \
+                  "but was #{actual}.")
+        backup_failed_github_file(build_file, attempt)
+        raise "Checksum for #{build_file} could not be verified."
+      end
+
+      log.info('Verified downloaded file checksum.')
+    end
+
+    # Backs up the failed file from a github verification.
+    #
+    # @param build_file [String] The build file to backup.
+    # @param attempt [Integer] Which attempt to verify the file failed.
+    def backup_failed_github_file(build_file, attempt)
+      basename = File.basename(build_file, '.tar.gz')
+      destination = File.join(Dir.tmpdir, basename,
+                              ".gh.failure.#{attempt}.tar.gz")
+      FileUtils.cp(build_file, destination)
+      log.info("Copied #{build_file} to #{destination}")
+    end
+
+    # Verifies the checksum for a file uploaded to s3.
+    #
+    # Uses a HEAD request and uses the etag, which is an MD5 hash.
+    #
+    # @param s3_name [String] The object's name on s3.
+    # @param checksum_file [String] Checksum file to verify the build.
+    # @param attempt [Integer] The attempt for this verification.
+    def verify_s3_checksum(s3_name, checksum_file, attempt: 0)
+      headers = s3_client.head_object(
+        key: s3_name,
+        bucket: @bucket_name
+      )
+      expected = File.read(checksum_file)
+      actual = headers.etag.tr('"', '')
+      if actual != expected
+        log.error("S3 file #{s3_name} checksum should be #{expected} but " \
+                  "was #{actual}.")
+        backup_failed_s3_file(s3_name, attempt)
+        raise "Checksum for #{s3_name} could not be verified."
+      end
+
+      log.info('Verified uploaded file checksum.')
+    end
+
+    # Backs up the failed file from an s3 verification.
+    #
+    # @param s3_name [String] The object's name on s3.
+    # @param attempt [Integer] Which attempt to verify the file failed.
+    def backup_failed_s3_file(s3_name, attempt)
+      basename = File.basename(s3_name, '.tar.gz')
+      destination = "#{Dir.tmpdir}/#{basename}.s3.failure.#{attempt}.tar.gz"
+      s3_client.get_object(
+        response_target: destination,
+        key: s3_name,
+        bucket: @bucket_name
+      )
+      log.info("Copied #{s3_name} to #{destination}")
+    end
+
     def doctor_check_hub_release_download
       sh_out('hub release download --help')
     rescue

data/lib/moonshot/ask_user_source.rb

@@ -0,0 +1,38 @@
+require 'colorize'
+
+module Moonshot
+  class AskUserSource
+    def get(sp)
+      return unless Moonshot.config.interactive
+
+      @sp = sp
+
+      prompt
+      loop do
+        input = gets.chomp
+
+        if String(input).empty? && @sp.default?
+          # We will use the default value, print it here so the output is clear.
+          puts 'Using default value.'
+          return
+        elsif String(input).empty?
+          puts "Cannot proceed without value for #{@sp.name}!"
+        else
+          @sp.set(String(input))
+          return
+        end
+
+        prompt
+      end
+    end
+
+    private
+
+    def prompt
+      print "(#{@sp.name})".light_black
+      print " #{@sp.description}" unless @sp.description.empty?
+      print " [#{@sp.default}]".light_black if @sp.default?
+      print ': '
+    end
+  end
+end

data/lib/moonshot/build_mechanism/github_release.rb

@@ -72,7 +72,7 @@ module Moonshot::BuildMechanism
       say("#{@changes}\n\n")
 
       q = "Do you want to tag and release this commit as #{version}? [y/n]"
-      raise Thor::Error, 'Release declined.' unless yes?(q)
+      raise 'Release declined.' unless yes?(q)
     end
 
     def git_tag(tag, sha, annotation)

data/lib/moonshot/build_mechanism/script.rb

@@ -41,7 +41,7 @@ class Moonshot::BuildMechanism::Script
 
   def post_build_hook(_version)
     unless File.exist?(@output_file) # rubocop:disable GuardClause
-      raise Thor::Error, 'Build command did not produce output file!'
+      raise 'Build command did not produce output file!'
     end
   end
 

data/lib/moonshot/command.rb

@@ -0,0 +1,64 @@
+require 'thor'
+
+module Moonshot
+  # A Command that is automatically registered with the Moonshot::CommandLine
+  class Command
+    module ClassMethods
+      # TODO: Can we auto-generate usage for commands with no positional arguments, at least?
+      attr_accessor :usage, :description
+    end
+
+    def self.inherited(base)
+      Moonshot::CommandLine.register(base)
+      base.extend(ClassMethods)
+    end
+
+    def parser
+      @use_interactive_logger = true
+
+      OptionParser.new do |o|
+        o.banner = "Usage: moonshot #{self.class.usage}"
+
+        o.on('-v', '--[no-]verbose', 'Show debug logging') do |v|
+          Moonshot.config.interactive_logger.debug = true if v
+        end
+
+        o.on('-nNAME', '--environment=NAME', 'Which environment to operate on.') do |v|
+          Moonshot.config.environment_name = v
+        end
+
+        o.on('--[no-]interactive-logger', TrueClass, 'Enable or disable fancy logging') do |v|
+          @use_interactive_logger = v
+        end
+
+        o.on('--[no-]show-all-events', FalseClass, 'Show all stack events during update') do |v|
+          Moonshot.config.show_all_stack_events = v
+        end
+
+        o.on('-pPARENT_STACK', '--parent=PARENT_STACK',
+             'Parent stack to import parameters from') do |v|
+          Moonshot.config.parent_stacks = [v]
+        end
+      end
+    end
+
+    private
+
+    # Build a Moonshot::Controller from the CLI options.
+    def controller
+      controller = Moonshot::Controller.new
+
+      # Apply CLI options to configuration defined by Moonfile.
+      controller.config = Moonshot.config
+
+      # Degrade to a more compatible logger if the terminal seems outdated,
+      # or at the users request.
+      if !$stdout.isatty || !@use_interactive_logger
+        log = Logger.new(STDOUT)
+        controller.config.interactive_logger = InteractiveLoggerProxy.new(log)
+      end
+
+      controller
+    end
+  end
+end

data/lib/moonshot/command_line.rb

@@ -0,0 +1,150 @@
+require 'thor'
+
+module Moonshot
+  # This class implements the command-line `moonshot` tool.
+  class CommandLine
+    def self.register(klass)
+      @classes ||= []
+      @classes << klass
+    end
+
+    def self.registered_commands
+      @classes || []
+    end
+
+    def run! # rubocop:disable AbcSize, CyclomaticComplexity, MethodLength, PerceivedComplexity
+      # Commands defined as Moonshot::Commands require a properly
+      # configured Moonshot.rb and supporting files. Without them, we only
+      # support `--help` and `new`.
+      return if handle_early_commands
+
+      # Find the Moonfile in this project.
+      orig_dir = Dir.pwd
+
+      loop do
+        break if File.exist?('Moonfile.rb')
+
+        if Dir.pwd == '/'
+          warn 'No Moonfile.rb found, are you in a project? Maybe you need to '\
+	        			'create one with `moonshot new <app_name>`?'
+          raise 'No Moonfile found'
+        end
+
+        Dir.chdir('..')
+      end
+
+      moonfile_dir = Dir.pwd
+      Dir.chdir(orig_dir)
+
+      # Load any plugins and CLI extensions relative to the Moonfile
+      if File.directory?(File.join(moonfile_dir, 'moonshot'))
+        load_plugins(moonfile_dir)
+        load_cli_extensions(moonfile_dir)
+      end
+
+      Object.include(Moonshot::ArtifactRepository)
+      Object.include(Moonshot::BuildMechanism)
+      Object.include(Moonshot::DeploymentMechanism)
+      load(File.join(moonfile_dir, 'Moonfile.rb'))
+
+      Moonshot.config.project_root = moonfile_dir
+
+      load_commands
+
+      # Determine what command is being run, which should be the first argument.
+      command = ARGV.shift
+      if %w(--help -h help).include?(command) || command.nil?
+        usage
+        return
+      end
+
+      # Dispatch to that command, by executing it's parser, then
+      # comparing ARGV to the execute methods arity.
+      unless @commands.key?(command)
+        usage
+        raise "Command not found '#{command}'"
+      end
+
+      handler = @commands[command].new
+      handler.parser.parse!
+
+      unless ARGV.size == handler.method(:execute).arity
+        warn handler.parser.help
+        raise "Invalid command line for '#{command}'."
+      end
+
+      handler.execute(*ARGV)
+    end
+
+    def load_plugins(moonfile_dir)
+      plugins_path = File.join(moonfile_dir, 'moonshot', 'plugins', '**', '*.rb')
+      Dir.glob(plugins_path).each do |file|
+        load(file)
+      end
+    end
+
+    def load_cli_extensions(moonfile_dir)
+      cli_extensions_path = File.join(moonfile_dir, 'moonshot', 'cli_extensions', '**', '*.rb')
+      Dir.glob(cli_extensions_path).each do |file|
+        load(file)
+      end
+    end
+
+    def usage
+      warn 'Usage: moonshot [command]'
+      warn
+      warn 'Valid commands include:'
+      fields = []
+      @commands.each do |c, k|
+        fields << [c, k.description]
+      end
+
+      max_len = fields.map(&:first).map(&:size).max
+
+      fields.each do |f|
+        line = format("  %-#{max_len}s # %s", *f)
+        warn line
+      end
+    end
+
+    def load_commands
+      @commands = {}
+
+      # Include all Moonshot::Command and Moonshot::SSHCommand
+      # derived classes as subcommands, with the description of their
+      # default task.
+      self.class.registered_commands.each do |klass|
+        next unless klass.instance_methods.include?(:execute)
+
+        command_name = commandify(klass)
+        @commands[command_name] = klass
+      end
+    end
+
+    def commandify(klass)
+      word = klass.to_s.split('::').last
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+      word.tr!('_'.freeze, '-'.freeze)
+      word.downcase!
+      word
+    end
+
+    def handle_early_commands
+      # If this is a legacy (Thor) help command, re-write it as
+      # OptionParser format.
+      if ARGV[0] == 'help'
+        ARGV.delete_at(0)
+        ARGV.push('-h')
+      elsif ARGV[0] == 'new'
+        require_relative 'commands/new'
+        app_name = ARGV[1]
+        ::Moonshot::Commands::New.run!(app_name)
+        return true
+      end
+
+      # Proceed to processing commands normally.
+      false
+    end
+  end
+end