kibo 0.1.2 → 0.3.0

data/lib/kibo/helpers/heroku.rb

@@ -0,0 +1,75 @@
+# It would be great if we could just use Heroku.read_credentials or `heroku whoami` 
+# to check for a user's current login. Well, we can't:
+#
+# - since heroku aggressively pushes its heroku toolbelt people 
+#   might be forced to uninstall the heroku gem.
+# - `heroku whoami` blocks for input, if the user is not logged in.
+#
+# Hence this code, which is based on code from the heroku gem.
+#
+# == Copyright and licensing ==================================================
+#
+# The heroku gem is licensed under the terms of the MIT license,
+# see the file License.MIT.
+#
+# The heroku has been created by Adam Wiggins, and is currently maintained
+# by Wesley Beary.
+module Kibo::Helpers::Heroku
+  require "netrc"
+
+  def whoami
+    (read_credentials || []).first
+  end
+
+  private
+  
+  def host
+    ENV['HEROKU_HOST'] || default_host
+  end
+
+  def default_host
+    "heroku.com"
+  end
+
+  def netrc_path
+    default = Netrc.default_path
+    encrypted = default + ".gpg"
+    if File.exists?(encrypted)
+      encrypted
+    else
+      default
+    end
+  end
+
+  def netrc   # :nodoc:
+    @netrc ||= begin
+      File.exists?(netrc_path) && Netrc.read(netrc_path)
+    rescue => error
+      if error.message =~ /^Permission bits for/
+        perm = File.stat(netrc_path).mode & 0777
+        abort("Permissions #{perm} for '#{netrc_path}' are too open. You should run `chmod 0600 #{netrc_path}` so that your credentials are NOT accessible by others.")
+      else
+        raise error
+      end
+    end
+  end
+
+  def read_credentials
+    if ENV['HEROKU_API_KEY']
+      ['', ENV['HEROKU_API_KEY']]
+    else
+      # read netrc credentials if they exist
+      if netrc
+        # force migration of long api tokens (80 chars) to short ones (40)
+        # #write_credentials rewrites both api.* and code.*
+        credentials = netrc["api.#{host}"]
+        if credentials && credentials[1].length > 40
+          @credentials = [ credentials[0], credentials[1][0,40] ]
+          write_credentials
+        end
+
+        netrc["api.#{host}"]
+      end
+    end
+  end
+end

data/lib/kibo/helpers/info.rb

@@ -0,0 +1,50 @@
+class Kibo::Helpers::Info < Array
+  def self.print(out = STDOUT, &block)
+    out.puts build(&block).to_s
+  end
+  
+  def self.build(&block)
+    info = new
+    yield info
+    info
+  end
+  
+  def head(msg)
+    push [ :head, msg ]
+  end
+  
+  def line(msg, value)
+    push [ :line, msg, value ]
+  end
+  
+  def to_s
+    key_length = map do |kind, msg, value| 
+      kind == :line ? msg.length : 0
+    end.max
+
+    key_length = 60 if key_length > 60
+    
+    key_format = "%#{key_length + 4}s"
+    
+    map do |kind, msg, value|
+      case kind
+      when :head
+        "== #{msg} " + "=" * (100 - msg.length)
+      when :line
+        case value
+        when [], nil then value = "<none>"
+        when Array   then value = value.map(&:inspect).join(", ")
+        end
+
+        if msg == ""
+          "#{key_format % msg}  #{value}"
+        elsif msg.length > key_length
+          msg = msg[0..20] + "..." + msg[(25 - key_length) ..-1]
+          "#{key_format % msg}: #{value}"
+        else
+          "#{key_format % msg}: #{value}"
+        end
+      end
+    end.join("\n")
+  end
+end

data/lib/kibo/helpers.rb

@@ -0,0 +1,70 @@
+module Kibo::Helpers
+end
+
+require_relative "./helpers/heroku"
+require_relative "./helpers/info"
+
+module Kibo::Helpers
+  extend self
+
+  extend Heroku
+  
+  def check_missing_remotes(mode = :warn)
+    return if missing_remotes.empty?
+
+    if mode == :warn
+      W  "Ignoring missing remote(s)", *missing_remotes
+      return
+    end
+
+    E <<-MSG
+Missing remote(s): #{missing_remotes.map(&:inspect).join(", ")}. Run
+
+  kibo --environment #{environment} create --all              # ... to create all missing remotes.
+  kibo --environment #{environment} spinup --force            # ... to ignore missing remotes.
+
+    MSG
+  end
+
+  # -- configure remotes ----------------------------------------------
+  
+  def configure_remote!(remote)
+    heroku "config:set", 
+      "RACK_ENV=#{environment}", 
+      "RAILS_ENV=#{environment}", 
+      "INSTANCE=#{instance_for_remote(remote)}", 
+      "--app", remote
+  end
+  
+  def instance_for_remote(remote)
+    remote[config.namespace.length + 1 .. -1]
+  end
+  
+  def configure_remote(remote)
+    # the correct value for the INSTANCE configuration setting is the 
+    # name of the of the remote without the namespace part; e.g. the 
+    # INSTANCE for the remote named "bountyhill-staging-twirl2" is 
+    # "staging-twirl2".
+    instance = remote[config.namespace.length + 1 .. -1]
+    current_instance = heroku "config:get", "INSTANCE", "--app", remote
+    return if instance == current_instance
+  end
+
+  # -- which remotes are defined, present and configured --------------
+  
+  def expected_remotes
+    namespace, environment = Kibo.config.namespace, Kibo.environment
+    
+    Kibo.config.processes.map do |name, count|
+      1.upto(count).map { |idx| "#{namespace}-#{environment}-#{name}#{idx}" }
+    end.flatten.sort
+  end
+
+  def configured_remotes
+    Kibo.config.remotes_by_process.values.flatten
+  end
+
+  def missing_remotes
+    expected_remotes - configured_remotes
+  end
+end

data/lib/kibo/log.rb

@@ -1,18 +1,44 @@
+require "bundler/ui"
+require "thor/shell"
+
+UI = Bundler::UI::Shell.new(Thor::Shell::Color.new)
+
 def log_message(msg, *args)
   return msg if args.empty?
   "#{msg}: " + args.map(&:inspect).join(", ")
 end
 
 def D(*args)
-  STDERR.puts log_message(*args)
+  UI.info log_message(*args)
 end
 
 def W(*args)
-  STDERR.puts log_message(*args)
+  UI.warn log_message(*args)
 end
 
 def E(*args)
-  STDERR.puts log_message(*args)
+  UI.error log_message(*args)
   exit 1
 end
 
+def B(*args, &block)
+  msg = log_message(*args)
+  W msg
+
+  start = Time.now
+  yield.tap do
+    W "#{msg}: #{(1000 * (Time.now - start)).to_i} msecs."
+  end
+end
+
+# Success!
+def S(*args)
+  UI.confirm log_message(*args)
+end
+
+def confirm!(msg)
+  puts msg
+  puts "\n\nPress ^C to abort or return to continue."
+  
+  STDIN.readline
+end

data/lib/kibo/system.rb

@@ -1,6 +1,6 @@
 module Kibo::System
   extend self
-  
+
   def heroku(*args)
     sys! "heroku", *args
   end
@@ -10,22 +10,42 @@ module Kibo::System
   end
 
   def sys(*args)
+    cmd = build_command(*args)
+    result = Kernel.send "`", "bash -c \"#{cmd}\""
+    if command_succeeded?(cmd)
+      result.chomp
+    end
+  end
+
+  def sys!(*args)
+    sys(*args) || exit(1)
+  end
+
+  def sh(*args)
+    cmd = build_command(*args)
+    system(cmd)
+    command_succeeded?(cmd)
+  end
+
+  def sh!(*args)
+    sh(*args) || exit(1)
+  end
+
+  private
+  
+  def build_command(*args)
     quiet = args.pop if args.last == :quiet
+    args[0].sub!(/^kibo\b/, $0)
     cmd = args.map(&:to_s).join(" ") 
     W cmd unless quiet
-    
-    # A command is run because it either is "quiet", i.e. is non-obstrusive anyway,
-    # or we are not in a dry. Dry run mode could go with some improvements, though.
-    if quiet || !Kibo::CommandLine.dry?
-      stdout = Kernel.send "`", "bash -c \"#{cmd}\""
-      stdout.chomp if $?.exitstatus == 0
-    else
-      ""
-    end
+    cmd
   end
 
-  def sys!(*args)
-    sys(*args) || E("Command failed: " + args.join(" "))
+  def command_succeeded?(cmd)
+    return true if $?.exitstatus == 0
+    
+    UI.error("Command failed: #{cmd}")
+    false
   end
 end
 

data/lib/kibo/version.rb

@@ -1,3 +1,3 @@
 module Kibo
-  VERSION = "0.1.2"
+  VERSION = "0.3.0"
 end

data/lib/kibo.rb

@@ -7,215 +7,29 @@ end
 require_relative "kibo/log"
 require_relative "kibo/system"
 require_relative "kibo/config"
+require_relative "kibo/commands"
 require_relative "kibo/commandline"
 
 module Kibo
   extend self
-
+  
   def config
-    @config ||= Config.new(CommandLine.kibofile)
+    @config ||= Config.new(kibofile)
   end
 
   def environment
-    Kibo::CommandLine.environment
-  end
-  
-  def expected_remotes
-    config.processes.inject([]) do |ary, (name, count)|
-      ary.concat 1.upto(count).map { |idx| "#{config.namespace}-#{environment}-#{name}#{idx}" }
-    end
-  end
-
-  def configured_remotes
-    config.remotes_by_process.values.flatten
-  end
-
-  def missing_remotes
-    expected_remotes - configured_remotes
-  end
-  
-  # -- configure a remote
-  
-  private
-  
-  def instance_for_remote(remote)
-    remote[config.namespace.length + 1 .. -1]
-  end
-  
-  public
-  
-  def configure_remote!(remote)
-    heroku "config:set", 
-      "RACK_ENV=#{environment}", 
-      "RAILS_ENV=#{environment}", 
-      "INSTANCE=#{instance_for_remote(remote)}", 
-      "--app", remote
-  end
-  
-  def configure_remote(remote)
-    # the correct value for the INSTANCE configuration setting is the 
-    # name of the of the remote without the namespace part; e.g. the 
-    # INSTANCE for the remote named "bountyhill-staging-twirl2" is 
-    # "staging-twirl2".
-    instance = remote[config.namespace.length + 1 .. -1]
-    current_instance = heroku "config:get", "INSTANCE", "--app", remote
-    return if instance == current_instance
-  end
-  
-  # --spin up/spin down remotes
-  
-  private
-  
-  def spin(processes)
-    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
+    CommandLine.environment
   end
   
-  public
-  
-  def spinup
-    check_missing_remotes(CommandLine.force? ? :warn : :error)
-    spin config.processes
-  end
-
-  def spindown
-    spin({})
-  end
-  
-  # reconfigure existing remotes
-  public 
-
-  # kibo [options] reconfigure                ... reconfigure all existing remotes
-  def reconfigure
-    check_missing_remotes :warn
-    
-    configured_remotes.each do |remote| 
-      configure_remote! remote
-    end
-  end
-
-  private
-  
-  def prepare_deployment
-  end
-  
-  def deploy_remote!(remote)
-    git "push", remote, "master"
-  end
-  
-  public
-  
-  def deploy
-    check_missing_remotes(CommandLine.force? ? :warn : :error)
-    
-    prepare_deployment
-    configured_remotes.each do |remote| 
-      deploy_remote! remote
-    end
-    
-    W "Deployment succeeded."
+  def run
+    Commands.send CommandLine.subcommand
   end
-  
-  private
-  
-  def check_missing_remotes(mode = :warn)
-    return if missing_remotes.empty?
-    
-    if mode == :warn
-      W  "Ignoring missing remote(s)", *missing_remotes
-      return
-    end
-
-    E <<-MSG
-Missing remote(s): #{missing_remotes.map(&:inspect).join(", ")}. Run
 
-  kibo --environment #{environment} create --all              # ... to create all missing remotes.
-  kibo --environment #{environment} spinup --force            # ... to ignore missing remotes.
-
-    MSG
+  def command_line
+    CommandLine
   end
-  
-  public
-  
-  def create
-    verify_heroku_login
-    
-    if CommandLine.all? 
-      instances = missing_remotes
-      if instances.empty?
-        W "Nothing to do."
-        exit 0
-      end
-    else
-      instances = CommandLine.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.heroku}.
-MSG
-
-    instances.each do |instance|
-      create_instance(instance)
-    end
-  end
-
-  def confirm!(msg)
-    puts msg
-    puts "\n\nPress ^C to abort or return to continue."
-    
-    STDIN.read
-  end
-  
-  private
-  
-  def verify_heroku_login
-    (Heroku::Auth.read_credentials || []).first.tap do |whoami|
-      msg = if !whoami
-        "Please log into heroku as #{config.heroku.inspect}."
-      elsif whoami != config.heroku
-        "You are currently logged into heroku as #{whoami.inspect}; please log in as #{config.heroku.inspect}."
-      end
-      
-      E "#{msg}\n\n\theroku auth:login" if msg
-    end
-  end
-  
-  def create_instance(remote)
-    # TODO: Test whether these instances already exist, using `heroku apps`
-    heroku "apps:create", remote, "--remote", remote
-  end
-  
-  public
-  
-  def run
-    self.send CommandLine.subcommand
+  def kibofile
+    command_line.kibofile
   end
 end

data/man/kibo.1

@@ -1,7 +1,7 @@
 .\" generated with Ronn/v0.7.3
 .\" http://github.com/rtomayko/ronn/tree/0.7.3
 .
-.TH "KIBO" "1" "August 2012" "Kibo 0.1.2" "Kibo Manual"
+.TH "KIBO" "1" "September 2012" "Kibo 0.3.0" "Kibo Manual"
 .
 .SH "NAME"
 \fBkibo\fR \- manage heroku applications
@@ -21,41 +21,94 @@
 .br
 \fBkibo [options] reconfigure\fR
 .
+.br
+\fBkibo [options] generate\fR
+.
 .SH "DESCRIPTION"
-kibo is an awesome program that does something very, very important\.
+kibo manages multiple application roles on single heroku dynos\.
 .
 .SH "DESCRIPTION"
-Foreman is a manager for Procfile\-based applications\. Its aim is to abstract away the details of the Procfile format, and allow you to either run your application directly or export it to some other process management format\.
+Kibo is a perfect addition to Procfile based deployment on heroku\.com\. While heroku itself provides adequate tools to manage a single application on multiple dynos, Kibo adds tools to manage multiple application roles on single dynos with automatic instance provisioning\.
+.
+.P
+The application roles are read from the Procfile (see foreman(1))\. The concurrency options \- i\.e\. the number of applications to run each role \- is read from the Kibofile\.
+.
+.SH "INSTANCE PROVISIONING"
+Each instance gets automatically configured using `heroku config\. kibo sets the environment variables INSTANCE, RAILS_ENV and RACK_ENV to reflect instance role and number and runtime environment\.
+.
+.IP "" 4
+.
+.nf
+
+INSTANCE="kibo\-staging\-web1"
+RAILS_ENV="staging"
+RACK_ENV="staging"
+.
+.fi
+.
+.IP "" 0
 .
 .SH "GLOBAL OPTIONS"
 The following options control how kibo is run:
 .
 .TP
 \fB\-e\fR, \fB\-\-environment\fR
-Set the target environment\.
+Set the target environment\. Defaults to "staging"
 .
 .TP
 \fB\-k\fR, \fB\-\-kibofile\fR
-Specify the Kibofile to use\.
+Specify an alternate Kibofile to use\.
 .
 .TP
 \fB\-p\fR, \fB\-\-procfile\fR
-Specify an alternate Procfile to load\.
+Specify an alternate Procfile to use\.
 .
 .SH "Kibofile"
-An example Kibofile is this:
+A Kibofile scaffold can be generated via \fBkibo generate\fR\. The following is an example:
 .
 .IP "" 4
 .
 .nf
 
+kibo:
+  # The email of the heroku account to create app instances on heroku\.
+  heroku: user@domain\.com
+  # You instances will be called \'kiboex\-staging\-web0\', \'kiboex\-production\-worker0\', etc\.
+  namespace: kibo
 defaults:
-    procfile: Procfile
-    namespace: radiospiel
-staging:
-    twirl: 1
+  procfile: Procfile\.other
+  web: 1
+  worker: 1
 production:
-    twirl: 2
+  web: 1
+  worker: 2
+.
+.fi
+.
+.IP "" 0
+.
+.P
+This defines the roles "web" and "worker", which are running at one resp\. two instances in the "production" environment\.
+.
+.SH "Example session"
+This is a session using the example Kibofile from above:
+.
+.IP "" 4
+.
+.nf
+
+# creates the heroku applications "kibo\-production\-web1",
+# "kibo\-production\-worker1", and "kibo\-production\-worker2"\.
+kibo \-e production create
+
+# deploy all applications\.
+kibo \-e production deploy
+
+# start all instances
+kibo \-e production spinup
+
+# stop all instances
+kibo \-e production spindown
 .
 .fi
 .