kibo 0.1.2 → 0.3.0

data/Gemfile

@@ -1,8 +1,9 @@
 source "http://rubygems.org"
 
-gem "heroku"
 gem "trollop"
+gem "thor"
 gem 'rake'
+gem 'netrc'
 
 group :development do
   gem 'ronn'

data/Gemfile.lock

@@ -0,0 +1,46 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    fakefs (0.3.2)
+    hpricot (0.8.6)
+    multi_json (1.3.6)
+    mustache (0.99.4)
+    netrc (0.7.7)
+    rake (0.9.2.2)
+    rdiscount (1.6.8)
+    ronn (0.7.3)
+      hpricot (>= 0.8.2)
+      mustache (>= 0.7.0)
+      rdiscount (>= 1.5.8)
+    rr (1.0.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    thor (0.16.0)
+    timecop (0.5.0)
+    trollop (2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakefs (~> 0.3.2)
+  netrc
+  rake
+  ronn
+  rr (~> 1.0.2)
+  rspec (~> 2.0)
+  simplecov
+  thor
+  timecop
+  trollop

data/kibo.gemspec

@@ -14,8 +14,8 @@ class Gem::Specification
     def source(*args); end
     def group(*args); end
 
-    def gem(name, options = {})
-      @scope.add_dependency(name)
+    def gem(name, *requirements)
+      @scope.add_dependency(name, *requirements)
     end
   end
   

data/lib/kibo/commandline.rb

@@ -1,53 +1,39 @@
 require "trollop"
+require "kibo/version"
 
 module Kibo::CommandLine
-  def self.method_missing(sym, *args, &block)
-    if block_given? || !args.empty?
-      super
-    elsif options.key?(sym)
-      options[sym]
-    elsif (sym.to_s =~ /(.*)\?/) && options.key?($1.to_sym)
-      !! options[$1.to_sym]
-    else
-      super
-    end 
-  end
+  extend self
   
-  def self.options
-    parse unless @options
-    @options
+  def options
+    parse; @options
   end
 
-  def self.subcommand
-    parse unless @options
-    @subcommand
+  def subcommand
+    parse; @subcommand
   end
 
-  def self.args
-    parse unless @options
-    @args
-  end
-  
-  def self.parse_and_get(name)
-    parse unless @options
-    instance_variable_get "@#{name}"
+  def args
+    parse; @args
   end
   
-  SUBCOMMANDS = %w(create deploy spinup spindown reconfigure)
+  private
   
-  def self.parse
+  def parse
+    return if @options
+
+    usage = Kibo::Commands.commands.map do |subcommand|
+      next unless description = Kibo::Commands.descriptions[subcommand.to_s]
+      "  kibo [options] %-30s ... %s" % [ subcommand, description ]
+    end.compact.join("\n")
+    
     @options = Trollop::options do
-       version "test 1.2.3 (c) 2008 William Morgan"
+       version "kibo #{Kibo::VERSION} (c) 2012 radiospiel"
         banner <<-EOS
-kibo is an awesome program that does something very, very important.
+kibo manages multiple application roles on single heroku dynos.
 
 Usage:
 
-  kibo [options] create                     ... create missing targets
-  kibo [options] deploy                     ... updates all remote instances
-  kibo [options] spinup                     ... starts all remote instances
-  kibo [options] spindown                   ... stops all remote instances
-  kibo [options] reconfigure                ... reconfigure all existing targets
+#{usage}
 
 where [options] are:
  
@@ -56,37 +42,42 @@ EOS
       opt :environment, "Set environment", :short => 'e', :type => String, :default => "staging"
       opt :kibofile, "Set Kibofile name", :short => 'k', :type => String, :default => "Kibofile"
       opt :procfile, "Set Procfile name", :short => 'p', :type => String, :default => "Procfile"
-      opt :dry, "Do nothing", :short => 'n'
 
-      stop_on SUBCOMMANDS
+      stop_on Kibo::Commands.commands
     end
 
     @subcommand = ARGV.shift # get the subcommand
 
-    unless SUBCOMMANDS.include?(@subcommand)
-      Trollop::die(@subcommand ? "Unknown subcommand #{@subcommand.inspect}" : "Missing subcommand")
+    unless Kibo::Commands.commands.include?(@subcommand)
+      if @subcommand
+        Trollop.die "Unknown subcommand #{@subcommand.inspect}"
+      else 
+        Trollop.die "Missing subcommand"
+      end
     end
 
     # Is there a specific subcommand options configuration?
-     
-    subcommand_options = 
-      case @subcommand
-      when "spinup" 
-        Trollop::options do
-          opt :force, "Ignore missing targets.", :short => "f"
-        end
-      when "deploy" 
-        Trollop::options do
-          opt :force, "Ignore outstanding changes.", :short => "f"
-        end
-      when "create" 
-        Trollop::options do
-          opt :all, "Create all missing targets.", :short => "a"
-        end
+
+    if proc = Kibo::Commands.options[@subcommand]
+      subcommand_options = Trollop::options do
+        instance_eval &proc
       end
-    
-    @options.update subcommand_options if subcommand_options
+
+      @options.update subcommand_options
+    end
 
     @args = ARGV.dup
   end
+
+  def method_missing(sym, *args, &block)
+    if block_given? || !args.empty?
+      super
+    elsif options.key?(sym)
+      options[sym]
+    elsif (sym.to_s =~ /(.*)\?/) && options.key?($1.to_sym)
+      !! options[$1.to_sym]
+    else
+      super
+    end 
+  end
 end

data/lib/kibo/commands/compress.rb

@@ -0,0 +1,85 @@
+module Kibo::Commands
+  subcommand :compress, "compress JS and CSS files" do
+    opt :quiet, "Be less verbose.", :short => "q"
+  end
+  
+  def compress
+    dirs = Kibo.command_line.args
+    dirs.each do |dir| compress_dir(dir) end
+  end
+  
+  private
+
+  def kibo_bin_path
+    File.join(File.dirname(__FILE__), "..", "bin")
+  end
+  
+  def yuicompressor(*args)
+    yuicompressor = "#{kibo_bin_path}/yuicompressor-2.4.7.jar"
+    Kibo::System.sys! "java", "-jar", yuicompressor, *args
+  end
+  
+  def compress_dir(dir)
+    css_files = Dir.glob File.join(dir, "**/*.css")
+    js_files = Dir.glob File.join(dir, "**/*.js")
+
+    files = css_files + js_files
+
+    old_sizes = files.inject({}) do |hash, file|
+      hash.update file => File.size(file)
+
+      file = file + ".gz"
+      hash.update file => File.size(file)
+    end
+
+    unless css_files.empty?
+      B "Compressing #{css_files.length} CSS files" do
+        yuicompressor "--type", "css", "-o", '.css$:.css.min', *css_files, :quiet
+      end
+    end
+    unless js_files.empty?
+      B "Compressing #{js_files.length} JS files" do
+        yuicompressor "--type", "js", "-o", '.js$:.js.min', *js_files, :quiet
+      end
+    end
+
+    unless files.empty?
+      B "gzipping #{files.length} files" do
+        files.each do |file|
+          FileUtils.cp "#{file}.min", file
+          Kibo::System.sys! "gzip", "-9", "-f", file, :quiet
+          FileUtils.mv "#{file}.min", file
+        end
+      end
+    end
+
+    Kibo::Helpers::Info.print do |info|
+      old_sum, new_sum = 0, 0
+
+      log_file = lambda do |file|
+        old_size, new_size = old_sizes[file], File.size(file)
+
+        unless Kibo.command_line.quiet?
+          info.line file, "#{old_size} -> #{new_size}"
+        end
+        old_sum += old_size
+        new_sum += new_size
+      end
+      
+      info.head "JS" unless Kibo.command_line.quiet?
+      
+      js_files.sort.each do |file|
+        log_file.call(file)
+      end
+      
+      info.head "CSS" unless Kibo.command_line.quiet?
+      
+      css_files.sort.each do |file|
+        log_file.call(file)
+      end
+
+      info.head "Summary" unless Kibo.command_line.quiet?
+      info.line "#{files.length} files", "#{old_sum} -> #{new_sum} byte: #{(new_sum * 100.0 / old_sum).round(1)} %"
+    end
+  end
+end

data/lib/kibo/commands/create.rb

@@ -0,0 +1,56 @@
+module Kibo::Commands
+  subcommand :create, "create missing targets" do
+    opt :all, "Create all missing targets.", :short => "a"
+  end
+
+  def create
+    verify_heroku_login
+
+    if Kibo.command_line.all? 
+      instances = missing_remotes
+      if instances.empty?
+        W "Nothing to do."
+        exit 0
+      end
+    else
+      instances = Kibo.command_line.args
+      if instances.empty?
+        W "Add the names of the remotes to create on the command line or use the --all parameter."
+        exit 0
+      end
+
+      # only create instances that are actually missing.
+      extra_instances = instances - missing_remotes
+      unless extra_instances.empty?
+        E <<-MSG
+kibo cannot create these instances for you: #{extra_instances.map(&:inspect).join(", ")}, because I don't not know anything about these.
+MSG
+      end
+    end
+
+    confirm! <<-MSG
+I am going to create these instances: #{instances.map(&:inspect).join(", ")}. Is this what you want? Note:
+You are logged in at heroku as #{config.account}.
+MSG
+
+    instances.each do |instance|
+      create_instance(instance)
+    end
+  end
+  
+  private
+  
+  def create_instance(remote)
+    # TODO: Test whether these instances already exist, using `heroku apps`
+    heroku "apps:create", remote, "--remote", remote
+  end
+
+  def verify_heroku_login
+    whoami = h.whoami
+    if !whoami
+      E "Please log in ('heroku auth:login') as #{config.account}."
+    elsif whoami != Kibo.config.account
+      E "You are currently logged in as #{whoami}; please log in ('heroku auth:login') as #{config.account}."
+    end
+  end
+end

data/lib/kibo/commands/deploy.rb

@@ -0,0 +1,69 @@
+module Kibo::Commands
+  subcommand :deploy, "updates all remote instances" do
+    opt :force, "Ignore outstanding changes.", :short => "f"
+  end
+
+  def deploy
+    if Kibo.command_line.force?
+      h.check_missing_remotes(:warn)
+    else
+      h.check_missing_remotes(:error)
+    end
+      #
+      # create a deployment branch, if there is none yet.
+      checkout_branch Kibo.environment
+    
+      git "merge", "master"
+      run_commands Kibo.config.deployment["pre"]
+      W "pre commands done"
+      
+      h.configured_remotes.each do |remote| 
+        deploy_remote! remote
+      end
+      
+      W "Deployment succeeded."
+      run_commands Kibo.config.deployment["post"]
+    rescue StandardError
+      W $!
+      raise
+    ensure
+      unless current_branch == "master"
+        git "reset", "--hard"
+        git "checkout", "master"
+      end
+    end
+
+  private
+  
+  def checkout_branch(name)
+    unless branches.include?(name)
+      Kibo::System.git "branch", name
+    end
+    
+    git "checkout", name
+  end
+  
+  def current_branch
+    `git branch`.split(/\n/).detect do |line|
+      line =~ /^* /
+    end.sub(/^\* /, "")
+  end
+  
+  def branches
+    branches = `git branch`
+    ("\n" + branches).split(/\n[\* ]+/).reject(&:empty?)
+  end
+    
+  def deploy_remote!(remote)
+    git "push", remote, "master"
+  end
+
+  def run_commands(commands)
+    return unless commands
+    commands = [ commands ] if commands.is_a?(String)
+
+    commands.each do |command|
+      Kibo::System.sh! command
+    end
+  end
+end

data/lib/kibo/commands/generate.rb

@@ -0,0 +1,53 @@
+module Kibo::Commands
+  subcommand :generate, "generate an example Kibofile"
+
+  def generate
+    if File.exists?(Kibo.kibofile)
+      E "#{Kibo.kibofile}: already existing."
+      return
+    end
+    
+    File.open(Kibo.kibofile, "w") do |io|
+      io.write kibofile_example
+    end
+    S "#{Kibo.kibofile}: created."
+  end
+
+  private
+  
+  def kibofile_example
+    namespace = File.basename Dir.getwd 
+    account = h.whoami || "user@domain.com"
+
+    kibo = <<-EXAMPLE
+# This is an example Kibofile. Use with kibo(1) to configure
+# remote instances.
+heroku:
+  #
+  # The heroku account to create application instances on heroku.
+  account: #{account}
+
+  # You instances will be called 'kiboex-staging-web0', 'kiboex-production-worker0', etc.
+  namespace: kiboex
+
+# What to do before and after deployment? These steps are run in the order 
+# defined here, and in an checked out deployment repository.
+deployment:
+  pre:
+    - git rm -rf public/assets || true
+    - rake assets:rebuild
+    - kibo compress --quiet public/assets
+    - git add -f public/assets
+    - git commit -m '[kibo] Updated assets'
+  post:
+    - heroku run rake db:migrate
+defaults:
+  web: 1
+  worker: 1
+production:
+  web: 1
+  worker: 2
+EXAMPLE
+  end
+end
+

data/lib/kibo/commands/info.rb

@@ -0,0 +1,19 @@
+module Kibo::Commands
+  subcommand :info, "show information about the current settings"
+
+  def info
+    Kibo::Helpers::Info.print do |info|
+      info.head "general"
+      info.line "environment", Kibo.environment
+
+      info.head "heroku"
+      info.line "current account", h.whoami
+      info.line "expected account", Kibo.config.account
+
+      info.head "remotes"
+      info.line "remotes", h.expected_remotes
+      info.line "configured", h.configured_remotes
+      info.line "missing", h.missing_remotes
+    end
+  end
+end

data/lib/kibo/commands/reconfigure.rb

@@ -0,0 +1,12 @@
+module Kibo::Commands
+  subcommand :reconfigure, "reconfigure all existing targets"
+
+  # kibo [options] reconfigure                ... reconfigure all existing remotes
+  def reconfigure
+    check_missing_remotes :warn
+    
+    configured_remotes.each do |remote| 
+      configure_remote! remote
+    end
+  end
+end

data/lib/kibo/commands/spin.rb

@@ -0,0 +1,39 @@
+# --spin up/spin down remotes
+module Kibo::Commands
+  subcommand :spinup, "starts all remote instances" do
+    opt :force, "Ignore missing targets.", :short => "f"
+  end
+
+  subcommand :spindown, "stops all remote instances"
+
+  def spinup
+    check_missing_remotes(Kibo.command_line.force? ? :warn : :error)
+    spin Kibo.config.processes
+  end
+
+  def spindown
+    spin({})
+  end
+
+  private
+  
+  def spin(processes)
+    Kibo.config.remotes_by_process.each do |name, remotes|
+      number_of_processes = processes[name] || 0
+      
+      remotes.each do |remote|
+        if number_of_processes > 0
+          configure_remote remote 
+          heroku "ps:scale", "#{name}=1", "--app", remote
+          number_of_processes -= 1
+        else
+          heroku "ps:scale", "#{name}=0", "--app", remote
+        end
+      end
+      
+      if number_of_processes > 0
+        W "Missing #{name} remote(s)", number_of_processes
+      end
+    end
+  end
+end

data/lib/kibo/commands.rb

@@ -0,0 +1,44 @@
+require_relative "helpers"
+require_relative "system"
+
+module Kibo::Commands
+  extend self
+
+  def self.options
+    @options ||= {}
+  end
+  
+  def self.descriptions
+    @descriptions ||= {}
+  end
+  
+  def self.subcommand(name, description = nil, &block)
+    options[name.to_s] = Proc.new if block_given?
+    descriptions[name.to_s] = description
+  end
+  
+  def self.commands
+    public_instance_methods.map(&:to_s)
+  end
+  
+  private 
+  
+  def h
+    Kibo::Helpers
+  end
+
+  def sys
+    Kibo::System
+  end
+
+  def git(*args)
+    sys.git *args
+  end
+
+  def heroku(*args)
+    sys.heroku *args
+  end
+end
+
+subfiles = Dir.glob( __FILE__.gsub(/\.rb$/, "/*.rb")).sort
+subfiles.each { |file| load file }

data/lib/kibo/config.rb

@@ -17,6 +17,8 @@ class Kibo::Configfile < Hash
 
         update key => value
       end
+  rescue
+    E "No such file", path
   end
 
   def die(lineno, msg)
@@ -42,21 +44,18 @@ class Kibo::Config
   def initialize(path)
     super()
 
-    @data = Hash.new do |hash, key|
-      W "#{key}: missing setting for #{environment.inspect} environment, using default."
-      hash[key] = DEFAULTS[key]
-    end
-
+    @data = DEFAULTS.dup
+    
     begin
       kibo = YAML.load File.read(path)
+      @data.update(kibo)
       @data.update(kibo["defaults"] || {})
       @data.update(kibo[environment] || {})
     rescue Errno::ENOENT
       W "No such file", path
-      @data = DEFAULTS
     end
     
-    @procfile = Kibo::Configfile.new(self["procfile"] || "Procfile")
+    @procfile = Kibo::Configfile.new(self["procfile"])
   end
   
   # processes are defined in the Procfile. The scaling, however, is defined in 
@@ -70,12 +69,25 @@ class Kibo::Config
   #
   # we need namespace-ENVIRONMENT-process<1>
   
+  # returns the heroku configuration
+  def heroku
+    self["heroku"] || {}
+  end
+  
+  # returns deployment specific configuration
+  def deployment
+    self["deployment"] || {}
+  end
+  
+  # returns the heroku namespace
   def namespace
-    self["namespace"] || raise("Please define a namespace in your Kibofile.")
+    heroku["namespace"] || E("Please set the heroku namespace in your Kibofile.")
   end
 
-  def heroku
-    self["heroku"] || raise("Please defined the heroku entry in your Kibofile")
+  # returns the heroku account email. This is the account that
+  # you should be logged in
+  def account
+    heroku["account"] || E("Please set the heroku account email in your Kibofile")
   end
 
   def remotes_by_process