moonshot 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cdc444c7d1abfc032353018913e6a8eccb90b035
+  data.tar.gz: 82a6a2f524bc812d9c0c7155b1437a10c378594d
+SHA512:
+  metadata.gz: 870266482ea59c020549ec66f4cd114b4cdb2dff89957a18387ff3eb6409b5f7f1b831c06c0503397ed79cc597bfdc659b8d9100bfeb9d2df3f177aad5953538
+  data.tar.gz: efbef2587e5b0305c608bcdd21695388145a98f981097eb5be875dcb27faa1cbeac1e354631891b3fd8ced6b3d898d7c3d59050199ea21c006decb65e8072c84

data/lib/moonshot/artifact_repository/s3_bucket.rb

@@ -0,0 +1,60 @@
+# The S3Bucket stores builds in an S3 Bucket.
+#
+# For example:
+#
+# def MyApplication < Moonshot::CLI
+#   self.artifact_repository = S3Bucket.new('my-application-builds')
+# end
+class Moonshot::ArtifactRepository::S3Bucket
+  include Moonshot::ResourcesHelper
+  include Moonshot::CredsHelper
+  include Moonshot::DoctorHelper
+
+  attr_reader :bucket_name
+
+  def initialize(bucket_name)
+    @bucket_name = bucket_name
+  end
+
+  def store_hook(build_mechanism, version_name)
+    unless build_mechanism.respond_to?(:output_file)
+      raise "S3Bucket does not know how to store artifacts from #{build_mechanism.class}, no method '#output_file'." # rubocop:disable LineLength
+    end
+
+    file = build_mechanism.output_file
+    bucket_name = @bucket_name
+    key = filename_for_version(version_name)
+
+    ilog.start_threaded "Uploading #{file} to s3://#{bucket_name}/#{key}" do |s|
+      s3_client.put_object(key: key, body: File.open(file), bucket: bucket_name)
+      s.success "Uploaded s3://#{bucket_name}/#{key} successfully."
+    end
+  end
+
+  def filename_for_version(version_name)
+    "#{version_name}.tar.gz"
+  end
+
+  private
+
+  def doctor_check_bucket_exists
+    s3_client.get_bucket_location(bucket: @bucket_name)
+    success "Bucket '#{@bucket_name}' exists."
+  rescue => e
+    # This is warning because the role you use for deployment may not actually
+    # be able to read builds, however the instance role assigned to the nodes
+    # might.
+    str = "Could not get information about bucket '#{@bucket_name}'."
+    warning(str, e.message)
+  end
+
+  def doctor_check_bucket_writable
+    s3_client.put_object(key: 'test-object', body: '', bucket: @bucket_name)
+    s3_client.delete_object(key: 'test-object', bucket: @bucket_name)
+    success 'Bucket is writable, new builds can be uploaded.'
+  rescue => e
+    # This is a warning because you may deploy to an environment where you have
+    # read access to builds, but could not publish a new build.
+    warning('Could not write to bucket, you may still be able to deploy existing builds.', e.message) # rubocop:disable LineLength
+  end
+end

data/lib/moonshot/artifact_repository/s3_bucket_via_github_releases.rb

@@ -0,0 +1,89 @@
+require 'moonshot/artifact_repository/s3_bucket'
+require 'moonshot/shell'
+require 'securerandom'
+require 'semantic'
+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
+    include Moonshot::BuildMechanism
+    include Moonshot::Shell
+
+    # @override
+    # If release version, transfer from GitHub to S3.
+    def store_hook(build_mechanism, version)
+      if release?(version)
+        if (@output_file = build_mechanism.output_file)
+          attach_release_asset(version, @output_file)
+          # Upload to s3.
+          super
+        else
+          # If there is no output file, assume it's on GitHub already.
+          transfer_release_asset_to_s3(version)
+        end
+      else
+        super
+      end
+    end
+
+    # @override
+    # If release version, transfer from GitHub to S3.
+    # @todo This is a super hacky place to handle the transfer, give
+    # artifact repositories a hook before deploy.
+    def filename_for_version(version)
+      s3_name = super
+      if !@output_file && release?(version) && !in_s3?(s3_name)
+        github_to_s3(version, s3_name)
+      end
+      s3_name
+    end
+
+    private
+
+    def release?(version)
+      ::Semantic::Version.new(version)
+    rescue ArgumentError
+      false
+    end
+
+    def in_s3?(key)
+      s3_client.head_object(key: key, bucket: bucket_name)
+    rescue ::Aws::S3::Errors::NotFound
+      false
+    end
+
+    def attach_release_asset(version, file)
+      # -m '' leaves message unchanged.
+      cmd = "hub release edit #{version} -m '' --attach=#{file}"
+      sh_step(cmd)
+    end
+
+    def transfer_release_asset_to_s3(version)
+      ilog.start_threaded "Transferring #{version} to S3" do |s|
+        key = filename_for_version(version)
+        s.success "Uploaded s3://#{bucket_name}/#{key} successfully."
+      end
+    end
+
+    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 = File.open(Dir.glob("*#{version}*.tar.gz").fetch(0))
+          s3_client.put_object(key: s3_name, body: file, bucket: bucket_name)
+        end
+      end
+    end
+
+    def doctor_check_hub_release_download
+      sh_out('hub release download --help')
+    rescue
+      critical '`hub release download` command missing, upgrade hub.' \
+               ' See https://github.com/github/hub/pull/1103'
+    else
+      success '`hub release download` command available.'
+    end
+  end
+end

data/lib/moonshot/build_mechanism/github_release.rb

@@ -0,0 +1,148 @@
+require 'forwardable'
+require 'moonshot/shell'
+require 'open3'
+require 'semantic'
+require 'shellwords'
+require 'tempfile'
+require 'vandamme'
+
+module Moonshot::BuildMechanism
+  # A build mechanism that creates a tag and GitHub release.
+  class GithubRelease # rubocop:disable Metrics/ClassLength
+    extend Forwardable
+    include Moonshot::ResourcesHelper
+    include Moonshot::DoctorHelper
+    include Moonshot::Shell
+
+    def_delegator :@build_mechanism, :output_file
+
+    # @param build_mechanism Delegates building after GitHub release is created.
+    def initialize(build_mechanism)
+      @build_mechanism = build_mechanism
+    end
+
+    def doctor_hook
+      super
+      @build_mechanism.doctor_hook
+    end
+
+    def resources=(r)
+      super
+      @build_mechanism.resources = r
+    end
+
+    def pre_build_hook(version)
+      @semver = ::Semantic::Version.new(version)
+      @target_version = [@semver.major, @semver.minor, @semver.patch].join('.')
+      sh_step('git fetch --tags upstream')
+      @sha = `git rev-parse HEAD`.chomp
+      validate_commit
+      @changes = validate_changelog(@target_version)
+      confirm_or_fail(@semver)
+      @build_mechanism.pre_build_hook(version)
+    end
+
+    def build_hook(version)
+      assert_state(version)
+      git_tag(version, @sha, @changes)
+      git_push_tag('upstream', version)
+      hub_create_release(@semver, @sha, @changes)
+      ilog.msg("#{releases_url}/tag/#{version}")
+      @build_mechanism.build_hook(version)
+    end
+
+    def post_build_hook(version)
+      assert_state(version)
+      @build_mechanism.post_build_hook(version)
+    end
+
+    private
+
+    # We carry state between hooks, make sure that's still valid.
+    def assert_state(version)
+      raise "#{version} != #{@semver}" unless version == @semver.to_s
+    end
+
+    def confirm_or_fail(version)
+      say("\nCommit Summary", :yellow)
+      say("#{@commit_detail}\n")
+      say('Commit CI Status', :yellow)
+      say("#{@ci_statuses}\n")
+      say("Changelog for #{version}", :yellow)
+      say("#{@changes}\n\n")
+
+      q = "Do you wan't to tag and release this commit as #{version}? [y/n]"
+      raise Thor::Error, 'Release declined.' unless yes?(q)
+    end
+
+    def git_tag(tag, sha, annotation)
+      cmd = "git tag -a #{tag} #{sha} --file=-"
+      sh_step(cmd, stdin: annotation)
+    end
+
+    def git_push_tag(remote, tag)
+      cmd = "git push #{remote} refs/tags/#{tag}:refs/tags/#{tag}"
+      sh_step(cmd) do
+        sleep 2 # GitHub needs a moment to register the tag.
+      end
+    end
+
+    def hub_create_release(semver, commitish, changelog_entry)
+      message = "#{semver}\n\n#{changelog_entry}"
+      cmd = "hub release create #{semver} --commitish=#{commitish}"
+      cmd << ' --prerelease' if semver.pre || semver.build
+      cmd << " --message=#{Shellwords.escape(message)}"
+      sh_step(cmd)
+    end
+
+    def validate_commit
+      cmd = "git show --stat #{@sha}"
+      sh_step(cmd, msg: "Validate commit #{@sha}.") do |_, out|
+        @commit_detail = out
+      end
+      cmd = "hub ci-status --verbose #{@sha}"
+      sh_step(cmd, msg: "Check CI status for #{@sha}.") do |_, out|
+        @ci_statuses = out
+      end
+    end
+
+    def validate_changelog(version)
+      changes = nil
+      ilog.start_threaded('Validate `CHANGELOG.md`.') do |step|
+        changes = fetch_changes(version)
+        step.success
+      end
+      changes
+    end
+
+    def fetch_changes(version)
+      parser = Vandamme::Parser.new(
+        changelog: File.read('CHANGELOG.md'),
+        format: 'markdown'
+      )
+      parser.parse.fetch(version) do
+        raise "#{version} not found in CHANGELOG.md"
+      end
+    end
+
+    def releases_url
+      `hub browse -u -- releases`.chomp
+    end
+
+    def doctor_check_upstream
+      sh_out('git remote | grep ^upstream$')
+    rescue => e
+      critical "git remote `upstream` not found.\n#{e.message}"
+    else
+      success 'git remote `upstream` exists.'
+    end
+
+    def doctor_check_hub_auth
+      sh_out('hub ci-status 0.0.0')
+    rescue => e
+      critical "`hub` failed, install hub and authorize it.\n#{e.message}"
+    else
+      success '`hub` installed and authorized.'
+    end
+  end
+end

data/lib/moonshot/build_mechanism/script.rb

@@ -0,0 +1,84 @@
+require 'open3'
+include Open3
+
+# Compile a release artifact using a shell script.
+#
+# The output file will be deleted before the script is run, and is expected to
+# exist after the script exits. Any non-zero exit status will be consider a
+# build failure, and any output will be displayed to the user.
+#
+# Creating a new Script BuildMechanism looks like this:
+#
+# class MyReleaseTool < Moonshot::CLI
+#   include Moonshot::BuildMechanism
+#   self.build_mechanism = Script.new('script/build.sh')
+# end
+#
+class Moonshot::BuildMechanism::Script
+  include Moonshot::ResourcesHelper
+  include Moonshot::DoctorHelper
+
+  attr_reader :output_file
+
+  def initialize(script, output_file: 'output.tar.gz')
+    @script = script
+    @output_file = output_file
+  end
+
+  def pre_build_hook(_version)
+    File.delete(@output_file) if File.exist?(@output_file)
+  end
+
+  def build_hook(version)
+    env = {
+      'VERSION' => version,
+      'OUTPUT_FILE' => @output_file
+    }
+    ilog.start_threaded "Running Script: #{@script}" do |s|
+      run_script(s, env: env)
+    end
+  end
+
+  def post_build_hook(_version)
+    unless File.exist?(@output_file) # rubocop:disable GuardClause
+      raise Thor::Error, 'Build command did not produce output file!'
+    end
+  end
+
+  private
+
+  def run_script(step, env: {}) # rubocop:disable AbcSize
+    popen2e(env, @script) do |_, out, wait|
+      output = []
+
+      loop do
+        str = out.gets
+        unless str.nil?
+          output << str.chomp
+          ilog.debug(str.chomp)
+        end
+        break if out.eof?
+      end
+
+      result = wait.value
+      if result.exitstatus == 0
+        step.success "Build script #{@script} exited successfully!"
+      end
+      unless result.exitstatus == 0
+        ilog.error "Build script failed with exit status #{result.exitstatus}!"
+        ilog.error 'Last 10 lines of output follows:'
+        output.pop(10).each { |l| ilog.error l }
+
+        step.failure "Build script #{@script} failed with exit status #{result.exitstatus}!"
+      end
+    end
+  end
+
+  def doctor_check_script_exists
+    if File.exist?(@script)
+      success "Script '#{@script}' exists."
+    else
+      critical "Could not find build script '#{@script}'!"
+    end
+  end
+end

data/lib/moonshot/build_mechanism/travis_deploy.rb

@@ -0,0 +1,70 @@
+require 'moonshot/shell'
+
+module Moonshot::BuildMechanism
+  # This simply waits for Travis-CI to finish building a job matching the
+  # version and 'BUILD=1'.
+  class TravisDeploy
+    include Moonshot::ResourcesHelper
+    include Moonshot::DoctorHelper
+    include Moonshot::Shell
+
+    attr_reader :output_file
+
+    def initialize(slug, pro: false)
+      @slug = slug
+      @endpoint = pro ? '--pro' : '--org'
+      @cli_args = "-r #{@slug} #{@endpoint}"
+    end
+
+    def pre_build_hook(_)
+    end
+
+    def build_hook(version)
+      job_number = find_build_and_job(version)
+      wait_for_job(job_number)
+      check_build(version)
+    end
+
+    def post_build_hook(_)
+    end
+
+    private
+
+    def find_build_and_job(version)
+      job_number = nil
+      ilog.start_threaded('Find Travis CI build') do |step|
+        sleep 2
+        build_out = sh_out("bundle exec travis show #{@cli_args} #{version}")
+        unless (job_number = build_out.match(/^#(\d+\.\d+) .+BUILD=1.+/)[1])
+          raise "Build for #{version} not found.\n#{build_out}"
+        end
+        step.success("Travis CI ##{job_number.gsub(/\..*/, '')} running.")
+      end
+      job_number
+    end
+
+    def wait_for_job(job_number)
+      cmd = "bundle exec travis logs #{@cli_args} #{job_number}"
+      # This log tailing fails at the end of the file. travis bug.
+      sh_step(cmd, fail: false)
+    end
+
+    def check_build(version)
+      cmd = "bundle exec travis show #{@cli_args} #{version}"
+      sh_step(cmd) do |step, out|
+        raise "Build didn't pass.\n#{build_out}" \
+          if out =~ /^#(\d+\.\d+) (?!passed).+BUILD=1.+/
+
+        step.success("Travis CI build for #{version} passed.")
+      end
+    end
+
+    def doctor_check_travis_auth
+      sh_out("bundle exec travis raw #{@endpoint} repos/#{@slug}")
+    rescue => e
+      critical "`travis` not available or not authorized.\n#{e.message}"
+    else
+      success '`travis` installed and authorized.'
+    end
+  end
+end

data/lib/moonshot/build_mechanism/version_proxy.rb

@@ -0,0 +1,55 @@
+require 'forwardable'
+require 'semantic'
+
+# This proxies build request do different mechanisms. One for semver compliant
+# releases and another for everything else.
+class Moonshot::BuildMechanism::VersionProxy
+  extend Forwardable
+  include Moonshot::ResourcesHelper
+
+  def_delegator :@active, :output_file
+
+  def initialize(release:, dev:)
+    @release = release
+    @dev = dev
+  end
+
+  def doctor_hook
+    @release.doctor_hook
+    @dev.doctor_hook
+  end
+
+  def resources=(r)
+    super
+    @release.resources = r
+    @dev.resources = r
+  end
+
+  def pre_build_hook(version)
+    active(version).pre_build_hook(version)
+  end
+
+  def build_hook(version)
+    active(version).build_hook(version)
+  end
+
+  def post_build_hook(version)
+    active(version).post_build_hook(version)
+  end
+
+  private
+
+  def active(version)
+    @active = if release?(version)
+                @release
+              else
+                @dev
+              end
+  end
+
+  def release?(version)
+    ::Semantic::Version.new(version)
+  rescue ArgumentError
+    false
+  end
+end

data/lib/moonshot/cli.rb

@@ -0,0 +1,146 @@
+require 'interactive-logger'
+
+# Base class for Moonshot-powered project tooling.
+module Moonshot
+  # The main entry point for Moonshot, this class should be extended by
+  # project tooling.
+  class CLI < Thor # rubocop:disable ClassLength
+    class_option(:name, aliases: 'n', default: nil, type: :string)
+    class_option(:interactive_logger, type: :boolean, default: true)
+    class_option(:verbose, aliases: 'v', type: :boolean)
+
+    class << self
+      attr_accessor :application_name
+      attr_accessor :artifact_repository
+      attr_accessor :auto_prefix_stack
+      attr_accessor :build_mechanism
+      attr_accessor :deployment_mechanism
+      attr_accessor :default_parent_stack
+      attr_reader :plugins
+
+      def plugin(plugin)
+        @plugins ||= []
+        @plugins << plugin
+      end
+
+      def parent(value)
+        @default_parent_stack = value
+      end
+
+      def check_class_configuration
+        raise Thor::Error, 'No application_name is set!' unless application_name
+      end
+
+      def exit_on_failure?
+        true
+      end
+
+      def inherited(base)
+        base.include(Moonshot::ArtifactRepository)
+        base.include(Moonshot::BuildMechanism)
+        base.include(Moonshot::DeploymentMechanism)
+      end
+    end
+
+    def initialize(*args)
+      super
+      @log = Logger.new(STDOUT)
+      @log.formatter = proc do |s, d, _, msg|
+        "[#{self.class.name} #{s} #{d.strftime('%T')}] #{msg}\n"
+      end
+      @log.level = options[:verbose] ? Logger::DEBUG : Logger::INFO
+
+      EnvironmentParser.parse(@log)
+      self.class.check_class_configuration
+    end
+
+    no_tasks do
+      # Build a Moonshot::Controller from the CLI options.
+      def controller # rubocop:disable AbcSize, CyclomaticComplexity, PerceivedComplexity
+        Moonshot::Controller.new do |config|
+          config.app_name             = self.class.application_name
+          config.artifact_repository  = self.class.artifact_repository
+          config.auto_prefix_stack    = self.class.auto_prefix_stack
+          config.build_mechanism      = self.class.build_mechanism
+          config.deployment_mechanism = self.class.deployment_mechanism
+          config.environment_name     = options[:name]
+          config.logger               = @log
+
+          # Degrade to a more compatible logger if the terminal seems outdated,
+          # or at the users request.
+          if !$stdout.isatty || !options[:interactive_logger]
+            config.interactive_logger = InteractiveLoggerProxy.new(@log)
+          end
+
+          config.show_all_stack_events = true if options[:show_all_events]
+          config.plugins = self.class.plugins if self.class.plugins
+
+          if options[:parent]
+            config.parent_stacks << options[:parent]
+          elsif self.class.default_parent_stack
+            config.parent_stacks << self.class.default_parent_stack
+          end
+        end
+      rescue => e
+        raise Thor::Error, e.message
+      end
+    end
+
+    desc :list, 'List stacks for this application.'
+    def list
+      controller.list
+    end
+
+    desc :create, 'Create a new environment.'
+    option(
+      :parent,
+      type: :string,
+      aliases: '-p',
+      desc: "Parent stack to import parameters from. (Default: #{default_parent_stack || 'None'})")
+    option :deploy, default: true, type: :boolean, aliases: '-d',
+                    desc: 'Choose if code should be deployed after stack is created'
+    option :show_all_events, desc: 'Show all stack events during update. (Default: errors only)'
+    def create
+      controller.create
+      controller.deploy_code if options[:deploy]
+    end
+
+    desc :update, 'Update the CloudFormation stack within an environment.'
+    option :show_all_events, desc: 'Show all stack events during update. (Default: errors only)'
+    def update
+      controller.update
+    end
+
+    desc :status, 'Get the status of an existing environment.'
+    def status
+      controller.status
+    end
+
+    desc 'deploy-code', 'Create a build from the working directory, and deploy it.' # rubocop:disable LineLength
+    def deploy_code
+      controller.deploy_code
+    end
+
+    desc 'build-version VERSION', 'Build a tarball of the software, ready for deployment.' # rubocop:disable LineLength
+    def build_version(version_name)
+      controller.build_version(version_name)
+    end
+
+    desc 'deploy-version VERSION_NAME', 'Deploy a versioned release to both EB environments in an environment.' # rubocop:disable LineLength
+    def deploy_version(version_name)
+      controller.deploy_version(version_name)
+    end
+
+    desc :delete, 'Delete an existing environment.'
+    option :show_all_events, desc: 'Show all stack events during update. (Default: errors only)'
+    def delete
+      controller.delete
+    end
+
+    desc :doctor, 'Run configuration checks against current environment.'
+    def doctor
+      success = controller.doctor
+      raise Thor::Error, 'One or more checks failed.' unless success
+    end
+  end
+end