bb_deploy 0.0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9cc6005046b0480f59f0ddd824b42ce3db5b4fc
+  data.tar.gz: ef97ccf9b0486fe4222cce699372fbb1aa291c96
+SHA512:
+  metadata.gz: 201d6e780955bd86311528ee7ed3109f3319018b6fd61a903b92a1b6b65ab32e68bb121536d3ce7ad91ec6b02b31c19a827c20aca542a915161123b006d0e82a
+  data.tar.gz: 7892a5234d19ee8bfab1a20395ca22d046676ab073d2189b33ff071bc947b7e6a0619bbbe22f5a2ce2b8fb685d40dd68bb5e83f0d1cf96c79e3d69c246370d95

data/lib/bb_deploy/config.rb

@@ -0,0 +1,44 @@
+require 'yaml'
+require_relative './heroku'
+
+module BbDeploy
+  class Config
+    attr_accessor :application_name,
+                  :application_urls,
+                  :logentries_token,
+                  :deployment_channel,
+                  :engineering_channel,
+                  :slack_webhook_key
+
+    class << self
+      def configuration
+        @configuration ||= BbDeploy::Config.new
+      end
+
+      def configure
+        yield(configuration)
+        configuration
+      end
+
+      def configure_from_yaml(file_path)
+        options = YAML.load(ERB.new(File.read(file_path)).result)
+        configure do |config|
+          %w(application_name application_urls deployment_channel engineering_channel).each do |key|
+            config.send("#{key}=", options[key])
+          end
+        end
+      end
+
+      def set_heroku_fields!(phase)
+        configure do |config|
+          config.logentries_token  = BbDeploy::Heroku.get_variable(phase, 'DEPLOY_LOG_TOKEN').freeze
+          config.slack_webhook_key = BbDeploy::Heroku.get_variable(phase, 'SLACK_WEBHOOK').freeze
+        end
+      end
+
+      def method_missing(method, *args)
+        configuration.send(method, *args)
+      end
+    end
+  end
+end

data/lib/bb_deploy/deployer.rb

@@ -0,0 +1,181 @@
+require 'pp'
+require_relative './config'
+require_relative './task'
+require_relative './logger'
+require_relative './git'
+require_relative './heroku'
+
+class BbDeploy::Deployer
+
+  include BbDeploy::Logger
+
+  attr_reader :phase
+
+  def initialize(phase)
+    BbDeploy::Config.configure_from_yaml('config/deploy.yml')
+    BbDeploy::Config.set_heroku_fields!(phase)
+    @phase = phase
+  end
+
+  # Environment inquiry methods
+  %w(qa staging production).each do |phase|
+    define_method("#{phase}?") { @phase == phase }
+  end
+
+  def deploy!
+    BbDeploy::Git.check_git_status!
+    check_access!
+    staging_checks if phase == 'staging'
+    prompt = "Do you want to deploy #{current_branch} to #{BbDeploy::Config.application_name} #{phase}?"
+    if phase == 'production'
+      do_deploy if BbDeploy::Task.ask(prompt, required_response: 'production', important: true)
+    else
+      do_deploy if BbDeploy::Task.ask(prompt)
+    end
+  end
+
+  private
+
+  def dputs(*msgs)
+    asterisks = "*" * 80
+    puts asterisks
+    puts(*msgs.map(&:to_s))
+    puts asterisks
+  end
+
+
+  def current_branch
+    BbDeploy::Git.current_branch(started_on_master?)
+  end
+
+  def do_deploy
+    branch = current_branch
+
+    chat_broadcast(":alert: '#{ENV['USER']}' is deploying the #{BbDeploy::Config.application_name} branch '#{branch}' to '#{phase}' :alert:", phase: phase, notify_eng_hub: true)
+
+    do_heroku_deploy!
+
+    open_in_browser
+
+    if phase != 'qa' && !started_on_master?
+      puts "Merging back to master ..."
+      puts `git checkout master && git pull && git merge -`
+      puts "You must now resolve any conflicts in the merge and then `git push origin master` ..."
+     end
+
+    chat_broadcast(":alertgreen: Deployment of the #{BbDeploy::Config.application_name} branch '#{branch}' to '#{phase}' completed! :alertgreen:", phase: phase, notify_eng_hub: true)
+  end
+
+  def logger
+    @logger ||= BbDeploy::Logger.logger(phase)
+  end
+
+  def check_access!
+    unless BbDeploy::Heroku.has_access?(phase)
+      exit_with_message("You do not have access to the #{BbDeploy::Config.application_name} #{phase} application!")
+    end
+  end
+
+  def exit_with_message(msg)
+    puts "\n#{msg}\n"
+    exit(0)
+  end
+
+  def do_heroku_deploy! # rubocop:disable all
+    run_migrations = run_migrations?
+
+    exit(0) if run_migrations && !BbDeploy::Task.ask("There are new migrations to run.  If you proceed,\n\n*** YOU WILL INCUR SITE DOWNTIME!!! ***\n\nDo you wish to proceed?")
+
+    enter_maint_mode = run_migrations || BbDeploy::Task.ask("Would you like to put #{BbDeploy::Config.application_name} into maintenance mode even though you don't have any migrations to run?")
+    if enter_maint_mode
+      stay_in_maint_mode = BbDeploy::Task.ask('Would you like to stay in maintenance mode after deployment, e.g. to run some rake tasks?')
+      logger.with_consolidated_logging { BbDeploy::Heroku.toggle_maintenance(mode: :on, phase: phase) }
+    end
+
+    push_release!
+
+    run_migrations! if run_migrations
+
+    if enter_maint_mode
+      if stay_in_maint_mode
+        dputs "********** NOTE: YOU ARE STILL IN MAINTENANCE MODE, AND MUST MANUALLY DISABLE IT VIA `rake heroku:maint:off:#{phase}` **********"
+      else
+        logger.with_consolidated_logging { BbDeploy::Heroku.toggle_maintenance(mode: :off, phase: phase) }
+      end
+    end
+  end
+
+  def run_migrations!
+    started_at = Time.current
+
+    chat_broadcast("Running migrations from #{BbDeploy::Config.application_name} branch '#{current_branch}' in #{phase} ...", phase: phase)
+    logger.with_consolidated_logging { BbDeploy::Heroku.migrate_db!(phase) }
+    chat_broadcast("Successfully ran migrations from #{BbDeploy::Config.application_name} branch '#{current_branch}' in #{phase}.", phase: phase)
+
+    time_spent = Time.zone.at(Time.current - started_at).getutc.strftime("%H:%M:%S")
+    # The only time started_on_master is non-nil is when creating a new staging branch
+    if started_on_master?
+      chat_broadcast("Yo, @jake - the #{BbDeploy::Config.application_name} branch '#{current_branch}' contains migrations that take #{time_spent} to run", phase: phase, notify_eng_hub: true)
+    end
+  end
+
+  def push_release!
+    puts "Deploying ..."
+    chat_broadcast("Pushing #{BbDeploy::Config.application_name} branch '#{current_branch}' to #{phase} ...", phase: phase)
+    logger.with_consolidated_logging { puts(BbDeploy::Git.push_to_phase(phase)) }
+  end
+
+  def open_in_browser
+    sleep 2 # because removing maint mode takes a couple seconds to propagate
+    host_and_path =
+      case phase
+      when 'qa'; BbDeploy::Config.application_urls['qa']
+      when 'staging'; BbDeploy::Config.application_urls['staging']
+      when 'production'; BbDeploy::Config.application_urls['production']
+      end
+
+    puts "Opening the site for inspection ..."
+    BbDeploy::Task.run("open https://#{host_and_path}")
+  end
+
+  def run_migrations?
+    sha = BbDeploy::Heroku.last_release_sha(phase)
+    BbDeploy::Git.migrations_present?(sha)
+  end
+
+  def started_on_master!
+    @started_on_mater = true
+  end
+
+  def started_on_master?
+    !!@started_on_master
+  end
+
+  def staging_checks
+    if BbDeploy::Git.on_master?
+      do_it = BbDeploy::Task.ask("You are on master. Do you want to create a ***NEW*** release branch from the HEAD of master and deploy it to #{BbDeploy::Config.application_name} #{phase}?")
+
+      if do_it
+        date = Time.zone.today.to_s(:db).tr('-', '_')
+        new_branch = "release_#{date}"
+
+        if BbDeploy::Git.local_release(new_branch).present?
+          exit_with_message("There already exists a local release branch named #{new_branch}!")
+        end
+
+        if BbDeploy::Git.remote_release(new_branch).present?
+          exit_with_message("There already exists a remote release branch named #{new_branch}!")
+        end
+
+        BbDeploy::Git.push_release_branch!
+
+        started_on_master!
+      end
+    elsif BbDeploy::Git.on_a_release_branch?
+      do_it = BbDeploy::Task.ask("Do you want to ***REDEPLOY*** the HEAD of your local version of #{current_branch} to #{BbDeploy::Config.application_name} #{phase}?")
+    else
+      exit_with_message("You may only deploy master or a release branch to #{BbDeploy::Config.application_name} #{phase}!")
+    end
+  end
+
+end

data/lib/bb_deploy/git.rb

@@ -0,0 +1,61 @@
+require_relative './task'
+
+module BbDeploy::Git
+  class << self
+    # NOTE - THE DEFAULT AUTO-MEMOIZATION CAN CAUSE ISSUES IF YOU FORGET IT'S HAPPENING, SO NOTE THAT IT OCCURS!!!
+    def current_branch(reload = false)
+      if reload || !@current_branch
+        # I don't know sed at all, hence I don't know which backslashes need to be doubled and which don't :(
+        cmd = 'git branch 2> /dev/null | sed -e \'/^[^*]/d\' -e \'s/* \(.*\)/\1/\''
+        result = `#{cmd}`
+        raise "Unable to determine the current branch name" if result.blank?
+        @current_branch = result.strip
+      else
+        @current_branch
+      end
+    end
+
+    def push_to_phase(phase)
+      `git push #{phase} HEAD:master --force`
+    end
+
+    def on_master?
+      current_branch == 'master'
+    end
+
+    def push_release_branch!
+      puts `git checkout -lb #{new_branch} && git push origin #{new_branch} -u`
+    end
+
+    def on_a_release_branch?
+      current_branch.start_with?('release_')
+    end
+
+    def check_git_status! # rubocop:disable Metrics/CyclomaticComplexity
+      puts "Running `git fetch` ... "
+      quietly { `git fetch` }
+      if `git log ..origin/#{current_branch}`.present?
+        exit(0) unless BbDeploy::Task.ask("There are new commits on the remote branch 'origin/#{current_branch}'. Are you sure you want to proceed?")
+      end
+      status_msg_a = `git status`.split(/(?:\n+)/)
+      if status_msg_a[1] =~ /your.branch.is.ahead/i
+        exit(0) unless BbDeploy::Task.ask("You have local, committed changes that have not been pushed to the remote.  Are you sure you want to proceed?")
+      end
+      unless status_msg_a.last =~ /nothing to commit/i
+        exit(0) unless BbDeploy::Task.ask("You have local, uncommitted changes.  Are you sure you want to proceed?")
+      end
+    end
+
+    def migrations_present?(sha)
+      `git diff #{sha} db/migrate`.present?
+    end
+
+    def local_release(branch_name)
+      `git branch --list "#{branch_name}"`
+    end
+
+    def remote_release(branch_name)
+      `git branch -r --list "origin/#{branch_name}"`
+    end
+  end
+end

data/lib/bb_deploy/heroku.rb

@@ -0,0 +1,42 @@
+require_relative './task'
+
+module BbDeploy::Heroku
+  class << self
+    def get_variable(phase, var_name)
+      @heroku_env_vars ||= {}
+      return @heroku_env_vars[var_name] if @heroku_env_vars[var_name]
+      token = heroku_run("heroku config:get #{var_name} --remote #{phase}")
+      if token.present?
+        token = token.chomp
+        @heroku_env_vars[var_name] = token.split.last
+      end
+      @heroku_env_vars[var_name]
+    end
+
+    def last_release_sha(phase)
+      heroku_run("heroku releases -n 25 --remote #{phase} | grep Deploy | head -n 1 | awk '{print $3}'")
+    end
+
+    def has_access?(phase)
+      heroku_info = heroku_run("heroku info --remote #{phase} 2>&1")
+      !(heroku_info =~ /You do not have access/i || heroku_info =~ /Enter your Heroku credentials./)
+    end
+
+    def migrate_db!(phase)
+      heroku_run(
+        "heroku run --size=PX rake db:migrate --remote #{phase}",
+        "heroku restart --remote #{phase}" # necessary to not have the web server gag
+      )
+    end
+
+    def toggle_maintenance(mode:, phase:)
+      Rake::Task["heroku:maint:#{mode}:#{phase}"].invoke
+    end
+
+    def heroku_run(*cmds)
+      # Heroku Toolbelt uses Ruby 1.9, which requires clearing the RUBYOPT var ...
+      puts "Running: #{cmds.map(&:inspect).join(", ")}"
+      BbDeploy::Task.run(*cmds.map { |cmd| cmd =~ /heroku/ ? "export RUBYOPT='' && #{cmd}" : cmd })
+    end
+  end
+end

data/lib/bb_deploy/logger.rb

@@ -0,0 +1,68 @@
+# Helper file for Logging/Slack notifications
+module BbDeploy::Logger
+  def self.logger(phase)
+    @logger ||= ConsolidatedLogger::Logentries.new(phase) # Phase-specific memoization
+  end
+
+  module ConsolidatedLogger
+    # For logging to our Logentries consolidated logging service
+    class Logentries
+      def initialize(phase)
+        @phase = phase
+      end
+
+      def with_consolidated_logging
+        @original_stdout = $stdout
+        # Logging something before assigning $stdout is necessary
+        # to avoid `SystemStackError: stack level too deep`?!
+        logger.send(:info, "logging #with_consolidated_logging")
+        $stdout = self
+        yield
+      ensure
+        $stdout = @original_stdout
+      end
+
+      # To replace $stdout we must #write
+      def write(msg)
+        # Apparently reassigning $stdout triggers a blank message.
+        @original_stdout.puts(msg)
+        logger.send(:info, "#{ENV['USER']} #{msg}") unless msg.blank?
+      end
+
+      def method_missing(method, *args)
+        # this is mostly a call to #flush. We do nothing.
+      end
+
+      # Logs originating here will be found in the BB
+      # Logentries account in the "Ruby Log" for each phase
+      def logger
+        @logger ||= Le.new(BbDeploy::Config.logentries_token)
+      end
+    end
+  end
+
+  def chat_broadcast(msg, phase:, notify_eng_hub: false)
+    attachment = [
+      {
+        fallback: "Deploying to #{phase}",
+        color: " ",
+        fields: [
+          {
+            title: "Details",
+            value: msg,
+            short: false
+          }
+        ]
+      }
+    ]
+
+    slack.ping("*Deploying to #{phase}*", attachments: attachment, channel: BbDeploy::Config.deployment_channel)
+    slack.ping("*Deploying to #{phase}*", attachments: attachment, channel: BbDeploy::Config.engineering_channel) if notify_eng_hub
+    @consolidated_logger ||= ConsolidatedLogger::Logentries.new(phase)
+    @consolidated_logger.logger.info("DEPLOY--#{msg}")
+  end
+
+  def slack
+    @slack ||= Slack::Notifier.new(BbDeploy::Config.slack_webhook_key)
+  end
+end

data/lib/bb_deploy/railtie.rb

@@ -0,0 +1,12 @@
+require 'bb_deploy'
+# require 'rails'
+
+module BbDeploy
+  class Railtie < Rails::Railtie
+    railtie_name :bb_deploy
+
+    rake_tasks do
+      load "tasks/deploy.rake"
+    end
+  end
+end

data/lib/bb_deploy/task.rb

@@ -0,0 +1,41 @@
+module BbDeploy::Task
+  class << self
+    def run(*cmds)
+      dry_run = !!ENV['DRY_RUN']
+      Dir.chdir(Rails.root)
+      result = cmds.map do |cmd|
+        cmd_s = "==> \`#{cmd}\`"
+        if dry_run
+          puts "DRY RUN ONLY"
+          puts cmd_s
+        else
+          with_timing(cmd_s) { `#{cmd}` || raise("System call failed: #{cmd.inspect}") }
+        end
+      end
+      result.last.try(:strip) unless dry_run
+    end
+
+    def ask(prompt, required_response: 'yes', important: false)
+      msg = prompt + "\n\nTyping anything other than '#{required_response}' will abort."
+      if important # Color important text RED and highlight the required response
+        msg = "\e[31m#{msg}\e[0m"
+        msg.sub!(/'#{required_response}'/, "\e[47m'#{required_response}'\e[49m")
+      end
+      puts
+      HighLine.new.ask(msg) =~ /\A#{required_response}\Z/i
+    end
+
+    private
+
+    def with_timing(what)
+      start = Time.current
+      puts
+      puts "Commencing #{what} ..."
+      result = yield
+      time = Time.zone.at(Time.current - start).getutc.strftime("%H:%M:%S")
+      puts "Finished #{what} in #{time}."
+      puts
+      result
+    end
+  end
+end

data/lib/bb_deploy.rb

@@ -0,0 +1,6 @@
+require 'pry'
+
+module BbDeploy
+  require 'bb_deploy/railtie' if defined?(Rails)
+  require 'bb_deploy/deployer'
+end

data/lib/tasks/deploy.rake

@@ -0,0 +1,17 @@
+require_relative '../bb_deploy'
+
+namespace :heroku do
+  namespace :deploy do
+    task qa: :environment do
+      BbDeploy::Deployer.new('qa').deploy!
+    end
+
+    task staging: :environment do
+      BbDeploy::Deployer.new('staging').deploy!
+    end
+
+    task production: :environment do
+      BbDeploy::Deployer.new('production').deploy!
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: bb_deploy
+version: !ruby/object:Gem::Version
+  version: 0.0.0.1
+platform: ruby
+authors:
+- Peter van Wesep
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: le
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: slack-notifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: peter@brightbytes.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bb_deploy.rb
+- lib/bb_deploy/config.rb
+- lib/bb_deploy/deployer.rb
+- lib/bb_deploy/git.rb
+- lib/bb_deploy/heroku.rb
+- lib/bb_deploy/logger.rb
+- lib/bb_deploy/railtie.rb
+- lib/bb_deploy/task.rb
+- lib/tasks/deploy.rake
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Shared gem for deploying BrightBytes repositories
+test_files: []