heroku-rails-saas 0.1.0

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,52 @@
+# Configuration settings for specific apps and thier environments should be located here
+# 'config/heroku/' and named appropiately they will be merged with the rest of the 
+# configuration settings
+
+# The following is an example config file 'config/heroku/awesomeapp.yml'
+# which map the apps and associated environments to your desired heroku app names
+# for example,
+#   awesomeapp:staging
+# would create the RACK_ENV=staging
+# and deploy to http://awesomeapp-staging.heroku.com
+
+# apps:
+#   production: awesomeapp
+#   staging: awesomeapp-staging
+#   legacy: awesomeapp-legacy
+
+# stacks:
+#   bamboo-mri-1.9.2
+
+# production:
+#   CONFIG_VAR1: "config1-production"
+
+# collaborators
+#   - "awesomeapp@somedomain.com"
+
+# domains:
+#   production:
+#     - "awesomeapp.com"
+#     - "www.awesomeapp.com"
+
+# production:
+#   - ssl:piggyback
+#   - cron:daily
+#   - newrelic:bronze
+
+
+# The following are configuration settings formally under the :all key
+# for all apps and thier environments
+config:
+  BUNDLE_WITHOUT: "test:development"
+  CONFIG_VAR1: "config1"
+  CONFIG_VAR2: "config2"
+
+# Be sure to add yourself as a collaborator, otherwise your
+# access to the app will be revoked.
+collaborators:
+  - "my-heroku-email@somedomain.com"
+  - "another-heroku-email@somedomain.com"
+
+addons:
+  - scheduler:standard
+  # add any other addons here

data/lib/heroku-rails.rb

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

data/lib/heroku-rails/config.rb

@@ -0,0 +1,146 @@
+require 'erb'
+
+module HerokuRails
+  class Config
+
+    SEPERATOR = ":"
+
+    class << self
+      def root
+        @heroku_rails_root || ENV["RAILS_ROOT"] || "."
+      end
+
+      def root=(root)
+        @heroku_rails_root = root
+      end
+
+      def app_name(app, env)
+        "#{app}#{SEPERATOR}#{env}"
+      end
+
+      def extract_environment_from(app_env)
+        name, env = app_env.split(SEPERATOR)
+        env
+      end
+    end
+
+    attr_accessor :settings
+
+    def initialize(config_files)
+      self.settings = aggregate_heroku_configs(config_files)
+    end
+
+    def apps
+      self.settings['apps'] || []
+    end
+
+    def app_names
+      apps.keys
+    end
+
+    # Returns the app name on heroku froma string format like so: `app:env`
+    # Allows for `rake <app:env> [<app:env>] <command>`
+    def app_name_on_heroku(string)
+      app_name, env = string.split(SEPERATOR)
+      apps[app_name][env] 
+    end
+
+    # return all enviromnets in this format app:env
+    def app_environments(env_filter="")
+      apps.each_with_object([]) do |(app, hsh), arr|
+        hsh.each { |env, app_name| arr << self.class.app_name(app, env) if (env_filter.nil? || env_filter.empty?) || env == env_filter }
+      end
+    end
+
+    # return all environments e.g. staging, production, development
+    def all_environments 
+      environments = apps.each_with_object([]) do |(app, hsh), arr|
+        hsh.each { |env, app_name| arr << env }
+      end
+      environments.uniq
+    end
+
+    # return the stack setting for a particular app environment
+    def stack(app_env)
+      name, env = app_env.split(SEPERATOR)
+      stacks = self.settings['stacks'] || {}
+      (stacks[name] && stacks[name][env]) || stacks['all']
+    end
+
+    def cmd(app_env)
+      if self.stack(app_env) =~ /cedar/i
+        'heroku run '
+      else
+        'heroku '
+      end
+    end
+    
+    # pull out the config setting hash for a particular app environment
+    def config(app_env)
+      name, env = app_env.split(SEPERATOR)
+      config = self.settings['config'] || {}
+      all = config['all'] || {}
+
+      app_configs = (config[name] && config[name].reject { |k,v| v.class == Hash }) || {}
+      # overwrite app configs with the environment specific ones
+      merged_environment_configs = app_configs.merge((config[name] && config[name][env]) || {})
+
+      # overwrite all configs with the environment specific ones
+      all.merge(merged_environment_configs)
+    end
+
+    # return a list of domains for a particular app environment
+    def domains(app_env)
+      name, env = app_env.split(SEPERATOR)
+      domains = self.settings['domains'] || {}
+      (domains[name] && domains[name][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_env)
+      name, env = app_env.split(SEPERATOR)
+      setting = self.settings[setting_key] || {}
+      all = setting['all'] || []
+
+      # add in collaborators from app environment to the ones defined in all
+      (all + ((setting[name] && setting[name][env]) || [])).uniq
+    end
+
+    private
+
+    def parse_yml(config_filepath, options)
+      if File.exists?(config_filepath)
+        config_hash = YAML.load(ERB.new(File.read(config_filepath)).result)
+        config_hash = add_all_namespace(config_hash) if options == :default
+        config_hash = add_app_namespace(File.basename(config_filepath, ".yml"), config_hash) if options == :apps
+        config_hash
+      end
+    end
+
+    def add_all_namespace(hsh)
+      hsh.each_with_object({}) { |(k,v), h| h[k] = Hash["all" => v] }
+    end
+
+    def add_app_namespace(app_name, hsh)
+      hsh["apps"] = hsh.delete("env") if hsh.has_key?("env")
+      hsh.each_with_object({}) { |(k,v), h| h[k] = Hash[app_name => v] }
+    end
+
+    def aggregate_heroku_configs(config_files)
+      hsh = {}
+      config_files[:apps].each_with_object(hsh) { |file, h| h.rmerge!(parse_yml(file, :apps)) }
+      # overwrite all configs with the environment specific ones
+      hsh.rmerge!(parse_yml(config_files[:default], :default))
+    end
+  end
+end

data/lib/heroku-rails/hash_recursive_merge.rb

@@ -0,0 +1,11 @@
+module HashRecursiveMerge
+  def rmerge!(other_hash)
+    merge!(other_hash) do |key, old_value, new_value|
+      old_value.class == self.class ? old_value.rmerge!(new_value) : new_value
+    end
+  end
+end
+
+class Hash
+  include HashRecursiveMerge
+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,278 @@
+require 'heroku/client'
+
+module HerokuRails
+  class Runner
+    def initialize(config)
+      @config = config
+      @environments = []
+    end
+
+    def authorize
+      @heroku ||= Heroku::Client.new(*Heroku::Auth.get_credentials)
+    end
+
+    # add a specific environment to the run list
+    def add_environment(env)
+      @environments << env
+    end
+
+    # use all environments or filter out production environments
+    def all_environments(filter=false)
+      @environments = @config.app_environments 
+      filter ? @environments.reject! { |app| app[production_regex] } : @environments
+    end
+
+    # use all heroku apps filtered by environments
+    def environments(env)
+      @environments = @config.app_environments(env)
+    end
+
+    # setup apps (create if necessary)
+    def setup_apps
+      authorize unless @heroku
+
+      # 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 unless @heroku
+      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 unless @heroku
+      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 unless @heroku
+      each_heroku_app do |app_env, app_name, repo|
+        # get the configuration that we are aiming towards
+        new_config = @config.config(app_env)
+
+        # default RACK_ENV and RAILS_ENV to the heroku_env (unless its manually set to something else)
+        new_config["RACK_ENV"]  = HerokuRails::Config.extract_environment_from(app_env) unless new_config["RACK_ENV"]
+        new_config["RAILS_ENV"] = HerokuRails::Config.extract_environment_from(app_env) unless new_config["RAILS_ENV"]
+        # 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}"
+          system_with_echo("#{@config.cmd(app_env)} rails runner 'Rails.cache.clear' --app #{app_name}")
+        end
+      end
+    end
+
+    # setup the addons for heroku
+    def setup_addons
+      authorize unless @heroku
+      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.any? {|x| x[/heroku-postgresql|shared-database|heroku-shared-postgresql|amazon_rds/]}
+
+        # 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} --confirm #{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 unless @heroku
+      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.nil? || @environments.empty?) && @config.apps.size == 1
+        @environments = [all_environments(true).try(:first)].compact
+      end
+
+      if @environments.present?
+        @environments.each do |env|
+          app_name = @config.app_name_on_heroku(env)
+          yield(env, app_name, "git@heroku.com:#{app_name}.git")
+        end
+      else
+        puts "\nYou must first specify at least one Heroku app:
+          rake <app>:<environment> [<app>:<environment>] <command>
+          rake awesomeapp:production restart
+          rake demo:staging deploy"
+
+        puts "\n\nYou can use also command all Heroku apps(except production environments) 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)
+      if @destroy_commands.try(:any?)
+        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"
+      end
+      # clear destroy commands
+      @destroy_commands = []
+    end
+
+    def command(*args)
+      raise "*** command \"#{args.join ' '}\" failed" unless system(*args)
+    end
+
+    private
+
+    def production_regex
+       Regexp.new("#{@config.class::SEPERATOR}(production|prod|live)")
+    end
+  end
+end