reinarb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a415a1d33bc56baa8ccd2e7d3ae8fd3fe6f426baa36031a7cfcd692035835970
+  data.tar.gz: 8e87077ee747bef1a456aa7cf6f1574dbf6db9f52303837b201a63809cf5a5d7
+SHA512:
+  metadata.gz: ac3d85dc8e66d9c16ecf7ad14155786c355a044ab02803dcb5fe4622588f2abd2927dba92975b72533194077d293a27e712a02862e34f152aee730259cea5ddd
+  data.tar.gz: 6d67ffd0e61f719250ad0f28ebef6dfcbbd9724034fa160181202733c3c1216db1355ee6e5d5b50f35e394f32b473f17499d8f871e0a67a74ddca069ca4f1077

data/bin/reina

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+require 'reina'
+require 'optparse'
+
+options = {
+  force: false,
+  strict: false
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: reina [options]"
+
+  opts.on('-f', '--force', 'Delete the existing apps without asking for deletion') do
+    options[:force] = true
+  end
+
+  opts.on('-s', '--strict', 'Enable the strict mode in which only the apps given in the CLI are considered rather than the whole suite') do
+    options[:strict] = true
+  end
+
+  opts.on('-v', '--version', 'Print the version') do
+    puts Reina::VERSION
+    exit
+  end
+end.parse!
+
+reina = Reina::Controller.new(ARGV.dup, options[:strict])
+
+if reina.existing_apps.present?
+  puts 'The following apps already exist on Heroku:'
+  puts reina.existing_apps.map { |a| "- #{a}" }
+
+  unless options[:force]
+    require 'readline'
+    abort if Readline.readline('Type "OK" to delete the apps above: ', true).strip != 'OK'
+  end
+
+  reina.delete_existing_apps!
+end
+
+apps_count = reina.apps.size
+
+if apps_count > 1
+  puts "Starting to deploy #{apps_count} apps..."
+else
+  puts "Starting to deploy one app..."
+end
+
+reina.deploy_parallel_apps!
+reina.deploy_non_parallel_apps!
+
+s = 's'.freeze if apps_count > 1
+puts "Deployment#{s} finished. Live at #{url}."

data/lib/reina.rb

@@ -0,0 +1,14 @@
+require 'excon'
+require 'platform-api'
+require 'git'
+require 'active_support/all'
+require 'parallel'
+require 'sinatra/base'
+require 'octokit'
+
+require 'reina/config'
+require 'reina/app'
+require 'reina/controller'
+require 'reina/github_controller'
+require 'reina/server'
+require 'reina/version'

data/lib/reina/app.rb

@@ -0,0 +1,190 @@
+module Reina
+  class App
+    DEFAULT_REGION = 'eu'.freeze
+    DEFAULT_STAGE  = 'staging'.freeze
+    DEFAULT_APP_NAME_PREFIX = CONFIG[:app_name_prefix].freeze
+
+    attr_reader :heroku, :name, :project, :issue_number, :branch, :g
+
+    def initialize(heroku, name, project, issue_number, branch)
+      @heroku       = heroku
+      @name         = name.to_s
+      @project      = project
+      @issue_number = issue_number
+      @branch       = branch
+    end
+
+    def fetch_repository
+      if Dir.exists?(name)
+        @g = Git.open(name)
+      else
+        @g = Git.clone(github_url, name)
+      end
+
+      g.pull('origin', branch)
+      g.checkout(g.branch(branch))
+
+      unless g.remotes.map(&:name).include?(remote_name)
+        g.add_remote(remote_name, remote_url)
+      end
+    end
+
+    def create_app
+      heroku.app.create(
+        'name'   => app_name,
+        'region' => project.fetch(:region, DEFAULT_REGION)
+      )
+    end
+
+    def install_addons
+      addons = project.fetch(:addons, []) + app_json.fetch('addons', [])
+      addons.each do |addon|
+        if addon.is_a?(Hash) && addon.has_key?('options')
+          addon['config'] = addon.extract!('options')
+        else
+          addon = { 'plan' => addon }
+        end
+
+        heroku.addon.create(app_name, addon)
+      end
+    end
+
+    def add_buildpacks
+      buildpacks = project.fetch(:buildpacks, []).map do |buildpack|
+        { 'buildpack' => buildpack }
+      end + app_json.fetch('buildpacks', []).map do |buildpack|
+        { 'buildpack' => buildpack['url'] }
+      end
+
+      heroku.buildpack_installation.update(app_name, 'updates' => buildpacks.uniq)
+    end
+
+    def set_env_vars
+      config_vars = project.fetch(:config_vars, {})
+      except = config_vars[:except]
+
+      if config_vars.has_key?(:from)
+        copy = config_vars.fetch(:copy, [])
+        config_vars = heroku.config_var.info_for_app(config_vars[:from])
+
+        vars_cache = {}
+        copy.each do |h|
+          unless h[:from].include?('#')
+            s = config_vars[h[:from]]
+            s << h[:append] if h[:append].present?
+            config_vars[h[:to]] = s
+            next
+          end
+
+          source, var = h[:from].split('#')
+          source_app_name = app_name_for(source)
+
+          if var == 'url'.freeze
+            config_vars[h[:to]] = "https://#{domain_name_for(source_app_name)}"
+          else
+            vars_cache[source_app_name] ||= heroku.config_var.info_for_app(source_app_name)
+            config_vars[h[:to]] = vars_cache[source_app_name][var]
+          end
+        end
+      end
+
+      config_vars.except!(*except) if except.present?
+
+      config_vars['APP_NAME']        = app_name
+      config_vars['HEROKU_APP_NAME'] = app_name
+      config_vars['DOMAIN_NAME']     = domain_name
+      config_vars['COOKIE_DOMAIN']   = '.herokuapp.com'.freeze
+
+      app_json.fetch('env', {}).each do |key, hash|
+        next if hash['value'].blank? || config_vars[key].present?
+        config_vars[key] = hash['value']
+      end
+
+      heroku.config_var.update(app_name, config_vars)
+    end
+
+    def setup_dynos
+      formation = app_json.fetch('formation', {})
+      return if formation.blank?
+
+      formation.each do |k, h|
+        h['size'] = 'free'
+
+        heroku.formation.update(app_name, k, h)
+      end
+    end
+
+    def add_to_pipeline
+      return if project[:pipeline].blank?
+
+      pipeline_id = heroku.pipeline.info(project[:pipeline])['id']
+      heroku.pipeline_coupling.create(
+        'app'      => app_name,
+        'pipeline' => pipeline_id,
+        'stage'    => DEFAULT_STAGE
+      )
+    end
+
+    def execute_postdeploy_scripts
+      script = app_json.dig('scripts', 'postdeploy')
+      return if script.blank?
+
+      return if heroku? && ENV['HEROKU_API_KEY'].blank?
+
+      `heroku run #{script} --app #{app_name}`
+    end
+
+    def deploy
+      g.push(remote_name, 'master')
+    end
+
+    def app_json
+      return @app_json if @app_json
+
+      f = File.join(name, 'app.json')
+      return {} unless File.exists?(f)
+
+      @app_json = JSON.parse(File.read(f))
+    end
+
+    def domain_name
+      domain_name_for(app_name)
+    end
+
+    def app_name
+      app_name_for(name)
+    end
+
+    def remote_name
+      "heroku-#{app_name}"
+    end
+
+    def parallel?
+      project[:parallel] != false
+    end
+
+    private
+
+    def domain_name_for(s)
+      "#{s}.herokuapp.com"
+    end
+
+    def app_name_for(s)
+      "#{DEFAULT_APP_NAME_PREFIX}#{s}-#{issue_number}"
+    end
+
+    def github_url
+      return "https://github.com/#{project[:github]}" if ENV['GITHUB_AUTH'].blank?
+
+      "https://#{ENV['GITHUB_AUTH']}@github.com/#{project[:github]}"
+    end
+
+    def remote_url
+      "https://git.heroku.com/#{app_name}.git"
+    end
+
+    def heroku?
+      ENV['DYNO'].present?
+    end
+  end
+end

data/lib/reina/config.rb

@@ -0,0 +1,22 @@
+module Reina
+  config_file = File.join(Dir.pwd, 'config.rb')
+
+  if File.exists?(config_file)
+    if ENV['CONFIG'].blank? || ENV['APPS'].blank?
+      require config_file
+      Reina::CONFIG = CONFIG
+      Reina::APPS = APPS
+    else
+      self.class.send(:remove_const, 'CONFIG')
+      self.class.send(:remove_const, 'APPS')
+    end
+  end
+
+  CONFIG = ActiveSupport::HashWithIndifferentAccess.new(
+    JSON.parse(ENV['CONFIG'])
+  ) if ENV['CONFIG'].present?
+
+  APPS = ActiveSupport::HashWithIndifferentAccess.new(
+    JSON.parse(ENV['APPS'])
+  ) if ENV['APPS'].present?
+end

data/lib/reina/controller.rb

@@ -0,0 +1,132 @@
+module Reina
+  class Controller
+    APP_COOLDOWN = 7 # seconds
+
+    def initialize(params, strict = false)
+      @params = params
+      @strict = strict
+
+      abort 'Please provide $PLATFORM_API' if CONFIG[:platform_api].blank?
+      abort 'Given PR number should be greater than 0' if issue_number <= 0
+
+      oversize = apps.select { |app| app.app_name.length >= 30 }.first
+      abort "#{oversize.app_name} is too long" if oversize.present?
+    end
+
+    def create_netrc
+      return if ENV['GITHUB_AUTH'].blank?
+
+      `git config --global user.name "#{ENV['GITHUB_NAME']}"`
+      `git config --global user.email "#{ENV['GITHUB_EMAIL']}"`
+
+      return if File.exists?('.netrc')
+
+      File.write(
+        '.netrc',
+        "machine git.heroku.com login #{ENV['GITHUB_EMAIL']} password #{ENV['HEROKU_API_KEY']}"
+      )
+    end
+
+    def deploy_parallel_apps!
+      Parallel.each(apps.select(&:parallel?)) do |app|
+        begin
+          deploy!(app)
+        rescue Git::GitExecuteError => e
+          puts "#{app.name}: #{e.message}"
+        rescue Exception => e
+          msg = e.respond_to?(:response) ? e.response.body : e.message
+          puts "#{app.name}: #{msg}"
+        end
+      end
+    end
+
+    def deploy_non_parallel_apps!
+      apps.reject(&:parallel?).each do |app|
+        begin
+          deploy!(app)
+        rescue Git::GitExecuteError => e
+          puts "#{app.name}: #{e.message}"
+        rescue Exception => e
+          msg = e.respond_to?(:response) ? e.response.body : e.message
+          puts "#{app.name}: #{msg}"
+        end
+      end
+    end
+
+    def delete_existing_apps!
+      existing_apps.each do |app|
+        puts "Deleting #{app}"
+        heroku.app.delete(app)
+      end
+    end
+
+    def existing_apps
+      # apps in common between heroku's list and ours
+      @_existing_apps ||= heroku.app.list.map { |a| a['name'] } & apps.map(&:app_name)
+    end
+
+    def heroku?
+      ENV['DYNO'].present?
+    end
+
+    def apps
+      return @_apps if @_apps.present?
+
+      # strict is when we only take in consideration the apps
+      # that are in both `params` and `APPS`
+      _apps = if strict
+        app_names = branches.keys
+        APPS.select { |name, _| app_names.include?(name) }
+      else
+        APPS
+      end
+
+      @_apps = _apps.map do |name, project|
+        branch = branches[name.to_s].presence || 'master'.freeze
+        App.new(heroku, name, project, issue_number, branch)
+      end
+    end
+
+    private
+
+    attr_reader :params, :strict
+
+    def heroku
+      @_heroku ||= PlatformAPI.connect_oauth(CONFIG[:platform_api])
+    end
+
+    def issue_number
+      @_issue_number ||= params.shift.to_i
+    end
+
+    def branches
+      @_branches ||= params.map { |param| param.split('#', 2) }.to_h
+    end
+
+    def deploy!(app)
+      puts "#{app.name}: Fetching from #{app.project[:github]}..."
+      app.fetch_repository
+
+      puts "#{app.name}: Provisioning #{app.app_name} on Heroku..."
+      app.create_app
+      app.install_addons
+      app.add_buildpacks
+      app.set_env_vars
+
+      puts "#{app.name}: Deploying to https://#{app.domain_name}..."
+      app.deploy
+
+      puts "#{app.name}: Cooldown..."
+      Kernel.sleep APP_COOLDOWN
+
+      puts "#{app.name}: Executing postdeploy scripts..."
+      app.execute_postdeploy_scripts
+
+      puts "#{app.name}: Setting up dynos..."
+      app.setup_dynos
+
+      puts "#{app.name}: Adding to pipeline..."
+      app.add_to_pipeline
+    end
+  end
+end

data/lib/reina/github_controller.rb

@@ -0,0 +1,176 @@
+module Reina
+  class SignatureError < StandardError
+    def message
+      'Signatures do not match'
+    end
+  end
+
+  class UnsupportedEventError < StandardError; end
+
+  class GitHubController
+    DEPLOY_TRIGGER = 'reina: d '.freeze
+    SINGLE_DEPLOY_TRIGGER = 'reina: r '.freeze
+    EVENTS = %w(issues issue_comment).freeze
+
+    def initialize(config)
+      @config = config
+    end
+
+    def dispatch(request)
+      @request = request
+
+      raise UnsupportedEventError unless EVENTS.include?(event)
+
+      authenticate!
+
+      if deploy_requested?
+        deploy!
+      elsif single_deploy_requested?
+        deploy!(true)
+      elsif issue_closed?
+        destroy!
+      end
+    end
+
+    def deployed_url
+      [
+        'https://', CONFIG[:app_name_prefix], repo_name, '-', issue_number, '.herokuapp.com'
+      ].join
+    end
+
+    private
+
+    attr_reader :config, :request
+
+    def authenticate!
+      hash = OpenSSL::HMAC.hexdigest(hmac_digest, config[:webhook_secret], raw_payload)
+      hash.prepend('sha1=')
+      raise SignatureError unless Rack::Utils.secure_compare(hash, signature)
+    end
+
+    def deploy_requested?
+      action == 'created'.freeze && comment_body.start_with?(DEPLOY_TRIGGER)
+    end
+
+    def single_deploy_requested?
+      action == 'created'.freeze && comment_body.start_with?(SINGLE_DEPLOY_TRIGGER)
+    end
+
+    def issue_closed?
+      action == 'closed'.freeze
+    end
+
+    def deploy!(strict = false)
+      reina = Controller.new(params, strict)
+      should_comment = config[:oauth_token].present?
+      reply = ->(msg) { octokit.add_comment(repo_full_name, issue_number, msg) }
+      url = deployed_url
+
+      fork do
+        apps_count = reina.apps.size
+
+        if should_comment
+          if apps_count > 1
+            reply.call("Starting to deploy #{apps_count} apps...")
+          else
+            reply.call("Starting to deploy one app...")
+          end
+        end
+
+        reina.create_netrc if reina.heroku?
+        reina.delete_existing_apps!
+        reina.deploy_parallel_apps!
+        reina.deploy_non_parallel_apps!
+
+        s = 's'.freeze if apps_count > 1
+        reply.call("Deployment#{s} finished. Live at #{url}.") if should_comment
+      end
+    end
+
+    def destroy!
+      reina = Controller.new(params)
+      return if reina.existing_apps.empty?
+
+      should_comment = config[:oauth_token].present?
+      reply = ->(msg) { octokit.add_comment(repo_full_name, issue_number, msg) }
+
+      fork do
+        reina.create_netrc if reina.heroku?
+        reina.delete_existing_apps!
+
+        reply.call('All the staging apps related to this issue have been deleted.') if should_comment
+      end
+    end
+
+    def octokit
+      return @_octokit if @_octokit.present?
+
+      client = Octokit::Client.new(access_token: config[:oauth_token])
+      user = client.user
+      user.login
+      @_octokit = client
+    end
+
+    def params
+      return [issue_number] if comment_body.blank?
+
+      [
+        issue_number,
+        comment_body
+          .lines[0]
+          .split(/#{DEPLOY_TRIGGER}|#{SINGLE_DEPLOY_TRIGGER}/)[1]
+          .split(' ')
+          .reject(&:blank?)
+      ].flatten
+    end
+
+    def signature
+      request.env['HTTP_X_HUB_SIGNATURE']
+    end
+
+    def event
+      request.env['HTTP_X_GITHUB_EVENT']
+    end
+
+    def action
+      payload['action']
+    end
+
+    def issue_number
+      payload.dig('issue', 'number')
+    end
+
+    def repo_name
+      payload.dig('repository', 'name')
+    end
+
+    def repo_full_name
+      payload.dig('repository', 'full_name')
+    end
+
+    def comment_body
+      payload.dig('comment', 'body')&.strip.to_s
+    end
+
+    def comment_author
+      payload.dig('comment', 'user', 'login')
+    end
+
+    def payload
+      return @_payload if @_payload.present?
+
+      @_payload ||= JSON.parse(raw_payload)
+    end
+
+    def raw_payload
+      return @_raw_payload if @_raw_payload.present?
+
+      request.body.rewind
+      @_raw_payload ||= request.body.read
+    end
+
+    def hmac_digest
+      @_hmac_digest ||= OpenSSL::Digest.new('sha1')
+    end
+  end
+end

data/lib/reina/server.rb

@@ -0,0 +1,27 @@
+module Reina
+  class Server < Sinatra::Base
+    set :show_exceptions, false
+
+    error SignatureError do
+      halt 403, env['sinatra.error'].message
+    end
+
+    error UnsupportedEventError do
+      halt 403, env['sinatra.error'].message
+    end
+
+    error Exception do
+      halt 500, 'Something bad happened... probably'
+    end
+
+    get '/' do
+      '<img src="https://i.imgur.com/UDxbOsz.png?1">'
+    end
+
+    post '/github' do
+      GitHubController.new(CONFIG[:github]).dispatch(request)
+      status 202
+      body ''
+    end
+  end
+end

data/lib/reina/version.rb

@@ -0,0 +1,3 @@
+module Reina
+  VERSION = '0.1.0'.freeze
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: reinarb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Giovanni Capuano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-30 00:00:00.000000000 Z
+dependencies: []
+description: Either used as GitHub bot or a CLI tool, reina performs setup and deployment
+  of your applications on Heroku.
+email: webmaster@giovannicapuano.net
+executables:
+- reina
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/reina
+- lib/reina.rb
+- lib/reina/app.rb
+- lib/reina/config.rb
+- lib/reina/controller.rb
+- lib/reina/github_controller.rb
+- lib/reina/server.rb
+- lib/reina/version.rb
+homepage: http://github.com/honeypotio/reina
+licenses:
+- BSD-2-Clause
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Bot to handle deploys and orchestrations of feature stagings hosted on Heroku.
+test_files: []