jw-heroku-rails 0.4.6

data/lib/generators/heroku/config_generator.rb

@@ -0,0 +1,19 @@
+module Heroku
+  module Generators
+    class ConfigGenerator < ::Rails::Generators::Base
+      desc "Generates a Heroku Config file at config/heroku.yml"
+
+      def self.source_root
+        @_heroku_gen_source_root ||= File.expand_path("../../templates", __FILE__)
+      end
+
+      def create_config_file
+        template 'heroku.yml', File.join('config', "heroku.yml")
+      end
+
+      def create_rake_file
+        template 'heroku.rake', File.join('lib', 'tasks', "heroku.rake")
+      end
+    end
+  end
+end

data/lib/generators/templates/heroku.rake

@@ -0,0 +1,33 @@
+# ### Shortcuts: uncomment these for easier to type deployments
+# ### e.g. rake deploy (instead of rake heroku:deploy)
+# ###
+# task :deploy =>  ["heroku:deploy"]
+# task :console => ["heroku:console"]
+# task :setup =>   ["heroku:setup"]
+# task :logs =>    ["heroku:logs"]
+# task :restart => ["heroku:restart"]
+
+# Heroku Deploy Callbacks
+namespace :heroku do
+
+  # runs before all the deploys complete
+  task :before_deploy do
+
+  end
+
+  # runs before each push to a particular heroku deploy environment
+  task :before_each_deploy, [:app_name] do |t,args|
+
+  end
+
+  # runs after each push to a particular heroku deploy environment
+  task :after_each_deploy, [:app_name] do |t,args|
+
+  end
+
+  # runs after all the deploys complete
+  task :after_deploy do
+
+  end
+
+end

data/lib/generators/templates/heroku.yml

@@ -0,0 +1,53 @@
+apps:
+  # map the environments to your desired heroku app names
+  # for example,
+  #   production: awesomeapp
+  # would create the RACK_ENV=production
+  # and deploy to http://awesomeapp.heroku.com
+  production: awesomeapp
+  staging: awesomeapp-staging
+  legacy: awesomeapp-legacy
+
+stacks:
+  # choose the stacks you want to use for each app.
+  # the all: setting sets the default
+  all: bamboo-mri-1.9.2
+
+  # override on a per environment basis
+  legacy: bamboo-ree-1.8.7
+
+config:
+  # choose the configuration settings for all environments
+  all:
+    BUNDLE_WITHOUT: "test:development"
+    CONFIG_VAR1: "config1"
+    CONFIG_VAR2: "config2"
+
+  # you can also override configuration settings for each environment
+  production:
+    CONFIG_VAR1: "config1-production"
+  staging:
+    CONFIG_VAR1: "config1-staging"
+
+collaborators:
+  # Be sure to add yourself as a collaborator, otherwise your
+  # access to the app will be revoked.
+  all:
+    - "my-heroku-email@somedomain.com"
+    - "another-heroku-email@somedomain.com"
+
+domains:
+  production:
+    - "awesomeapp.com"
+    - "www.awesomeapp.com"
+
+addons:
+  all:
+    - custom_domains:basic
+    # add any other addons here
+
+  production:
+    - ssl:piggyback
+    - cron:daily
+    # - newrelic:bronze
+    # production env specific addons here

data/lib/heroku-rails.rb

@@ -0,0 +1,3 @@
+require 'heroku-rails/config'
+require 'heroku-rails/runner'
+require 'heroku-rails/railtie' if defined?(::Rails::Railtie)

data/lib/heroku-rails/config.rb

@@ -0,0 +1,86 @@
+require 'erb'
+
+module HerokuRails
+  class Config
+
+    class << self
+      def root
+        @heroku_rails_root || ENV["RAILS_ROOT"] || "."
+      end
+      def root=(root)
+        @heroku_rails_root = root
+      end
+    end
+
+    attr_accessor :settings
+
+    def initialize(config_filepath)
+      if File.exists?(config_filepath)
+        self.settings = YAML.load(ERB.new(File.read(config_filepath)).result) || {}
+      else
+        self.settings = {}
+      end
+    end
+
+    def apps
+      self.settings['apps'] || {}
+    end
+
+    def app_names
+      apps.values
+    end
+
+    def app_environments
+      apps.keys
+    end
+
+    # return the stack setting for a particular app environment
+    def stack(app_env)
+      stacks = self.settings['stacks'] || {}
+      stacks[app_env] || stacks['all']
+    end
+
+    def rake_cmd(app_env)
+      if self.stack(app_env) =~ /cedar/i
+        'heroku run rake'
+      else
+        'heroku rake'
+      end
+    end
+
+    # pull out the config setting hash for a particular app environment
+    def config(app_env)
+      config = self.settings['config'] || {}
+      all = config['all'] || {}
+
+      # overwrite all configs with the environment specific ones
+      all.merge(config[app_env] || {})
+    end
+
+    # return a list of domains for a particular app environment
+    def domains(app_env)
+      domains = self.settings['domains'] || {}
+      domains[app_env] || []
+    end
+
+    # return a list of collaborators for a particular app environment
+    def collaborators(app_env)
+      app_setting_list('collaborators', app_env)
+    end
+
+    # return a list of addons for a particular app environment
+    def addons(app_env)
+      app_setting_list('addons', app_env)
+    end
+
+    protected
+
+    def app_setting_list(setting_key, app)
+      setting = self.settings[setting_key] || {}
+      all = setting['all'] || []
+
+      # add in collaborators from app environment to the ones defined in all
+      (all + (setting[app] || [])).uniq
+    end
+  end
+end

data/lib/heroku-rails/railtie.rb

@@ -0,0 +1,8 @@
+module HerokuRails
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      HerokuRails::Config.root = ::Rails.root
+      load 'heroku/rails/tasks.rb'
+    end
+  end
+end

data/lib/heroku-rails/runner.rb

@@ -0,0 +1,273 @@
+require 'heroku-api'
+
+module HerokuRails
+  class Runner
+    def initialize(config)
+      @config = config
+      @environments = []
+    end
+
+    def authorize
+      @heroku ||= Heroku::Auth.client
+    end
+
+    # add a specific environment to the run list
+    def add_environment(env)
+      @environments << env
+    end
+
+    # use all environments
+    def all_environments
+      @environments = @config.app_environments
+    end
+
+    # setup apps (create if necessary)
+    def setup_apps
+      authorize
+
+      # get a list of all my current apps on Heroku (so we don't create dupes)
+      @my_apps = @heroku.list.map{|a| a.first}
+
+      each_heroku_app do |heroku_env, app_name, repo|
+        next if @my_apps.include?(app_name)
+
+        stack = @config.stack(heroku_env)
+        stack_option = " --stack #{stack}" if stack.to_s.size > 0
+        creation_command "heroku create #{app_name}#{stack_option} --remote #{app_name}"
+      end
+    end
+
+    # setup the stacks for each app (migrating if necessary)
+    def setup_stacks
+      authorize
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the intended stack setting
+        stack = @config.stack(heroku_env)
+
+        # get the remote info about the app from heroku
+        heroku_app_info = @heroku.info(app_name) || {}
+
+        # if the stacks don't match, then perform a migration
+        if stack != heroku_app_info[:stack]
+          puts "Migrating the app: #{app_name} to the stack: #{stack}"
+          creation_command "heroku stack:migrate #{stack} --app #{app_name}"
+        end
+      end
+    end
+
+    # setup the list of collaborators
+    def setup_collaborators
+      authorize
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the remote info about the app from heroku
+        heroku_app_info = @heroku.info(app_name) || {}
+
+        # get the intended list of collaborators to add
+        collaborator_emails = @config.collaborators(heroku_env)
+
+        # add current user to collaborator list (always)
+        collaborator_emails << @heroku.user unless collaborator_emails.include?(@heroku.user)
+        collaborator_emails << heroku_app_info[:owner] unless collaborator_emails.include?(heroku_app_info[:owner])
+
+        # get existing collaborators
+        existing_emails = heroku_app_info[:collaborators].to_a.map{|c| c[:email]}
+
+        # get the list of collaborators to delete
+        existing_emails.each do |existing_email|
+          # check to see if we need to delete this person
+          unless collaborator_emails.include?(existing_email)
+            # delete that collaborator if they arent on the approved list
+            destroy_command "heroku sharing:remove #{existing_email} --app #{app_name}"
+          end
+        end
+
+        # get the list of collaborators to add
+        collaborator_emails.each do |collaborator_email|
+          # check to see if we need to add this person
+          unless existing_emails.include?(collaborator_email)
+            # add the collaborator if they are not already on the server
+            creation_command "heroku sharing:add #{collaborator_email} --app #{app_name}"
+          end
+        end
+
+        # display the destructive commands
+        output_destroy_commands(app_name)
+      end
+    end
+
+    # setup configuration
+    def setup_config
+      authorize
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the configuration that we are aiming towards
+        new_config = @config.config(heroku_env)
+
+        # default RACK_ENV to the heroku_env (unless its manually set to something else)
+        unless new_config["RACK_ENV"].to_s.length > 0
+          new_config["RACK_ENV"] = heroku_env
+        end
+
+        # get the existing config from heroku's servers
+        existing_config = @heroku.config_vars(app_name) || {}
+
+        # find the config variables to add
+        add_config = {}
+        new_config.each do |new_key, new_val|
+          add_config[new_key] = new_val unless existing_config[new_key] == new_val
+        end
+
+        # persist the changes onto heroku
+        unless add_config.empty?
+          # add the config
+          set_config = ""
+          add_config.each do |key, val|
+            set_config << "#{key}='#{val}' "
+          end
+
+          creation_command "heroku config:add #{set_config} --app #{app_name}"
+        end
+      end
+    end
+
+    # setup the addons for heroku
+    def setup_addons
+      authorize
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the addons that we are aiming towards
+        addons = @config.addons(heroku_env)
+
+        # get the addons that are already on the servers
+        existing_addons = (@heroku.installed_addons(app_name) || []).map{|a| a["name"]}
+
+        # all apps need the shared database
+        addons << "shared-database:5mb" unless addons.index("shared-database:5mb") || addons.index("shared-database:20gb")
+
+        # add "custom_domains" if that addon doesnt already exist
+        # and we have domains configured for this app
+        addons << "custom_domains:basic" unless @config.domains(heroku_env).empty? or
+                                                addons.any?{|a| a =~ /custom_domains/} or
+                                                existing_addons.any?{|a| a =~ /custom_domains/}
+
+        # remove the addons that need to be removed
+        existing_addons.each do |existing_addon|
+          # check to see if we need to delete this addon
+          unless addons.include?(existing_addon)
+            # delete this addon if they arent on the approved list
+            destroy_command "heroku addons:remove #{existing_addon} --app #{app_name}"
+          end
+        end
+
+        # add the addons that dont exist already
+        addons.each do |addon|
+          # check to see if we need to add this addon
+          unless existing_addons.include?(addon)
+            # add this addon if they are not already added
+            creation_command "heroku addons:add #{addon} --app #{app_name}"
+          end
+        end
+
+        # display the destructive commands
+        output_destroy_commands(app_name)
+      end
+    end
+
+    # setup the domains for heroku
+    def setup_domains
+      authorize
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the domains that we are aiming towards
+        domains = @config.domains(heroku_env)
+
+        # get the domains that are already on the servers
+        existing_domains = (@heroku.list_domains(app_name) || []).map{|a| a[:domain]}
+
+        # remove the domains that need to be removed
+        existing_domains.each do |existing_domain|
+          # check to see if we need to delete this domain
+          unless domains.include?(existing_domain)
+            # delete this domain if they arent on the approved list
+            destroy_command "heroku domains:remove #{existing_domain} --app #{app_name}"
+          end
+        end
+
+        # add the domains that dont exist already
+        domains.each do |domain|
+          # check to see if we need to add this domain
+          unless existing_domains.include?(domain)
+            # add this domain if they are not already added
+            creation_command "heroku domains:add #{domain} --app #{app_name}"
+          end
+        end
+
+        # display the destructive commands
+        output_destroy_commands(app_name)
+      end
+    end
+
+    # cycles through each configured heroku app
+    # yields the environment name, the app name, and the repo url
+    def each_heroku_app
+
+      if @config.apps.size == 0
+        puts "\nNo heroku apps are configured. Run:
+          rails generate heroku:config\n\n"
+        puts "this will generate a default config/heroku.yml that you should edit"
+        puts "and then try running this command again"
+
+        exit(1)
+      end
+
+      if @environments.blank? && @config.apps.size == 1
+        @environments = [@config.app_environments.first]
+      end
+
+      if @environments.present?
+        @environments.each do |heroku_env|
+          app_name = @config.apps[heroku_env]
+          yield(heroku_env, app_name, "git@heroku.com:#{app_name}.git")
+        end
+      else
+        puts "\nYou must first specify at least one Heroku app:
+          rake <app> [<app>] <command>
+          rake production restart
+          rake demo staging deploy"
+
+        puts "\n\nYou can use also command all Heroku apps for this project:
+          rake all heroku:setup\n"
+
+        exit(1)
+      end
+    end
+
+    def system_with_echo(*args)
+      puts args.join(' ')
+      command(*args)
+    end
+
+    def creation_command(*args)
+      system_with_echo(*args)
+    end
+
+    def destroy_command(*args)
+      # puts args.join(' ')
+      @destroy_commands ||= []
+      @destroy_commands << args.join(' ')
+    end
+
+    def output_destroy_commands(app)
+      puts "The #{app} had a few things removed from the heroku.yml."
+      puts "If they are no longer neccessary, then run the following commands:\n\n"
+      (@destroy_commands || []).each do |destroy_command|
+        puts destroy_command
+      end
+      puts "\n\nthese commands may cause data loss so make sure you know that these are necessary"
+      # clear destroy commands
+      @destroy_commands = []
+    end
+
+    def command(*args)
+      system(*args)
+    end
+
+  end
+end