mina 0.1.0

data/lib/mina/helpers.rb

@@ -0,0 +1,278 @@
+module Mina
+  module Helpers
+    # Invokes another Rake task.
+    def invoke(task)
+      Rake.application.invoke_task task
+    end
+
+    # Evaluates an ERB block and returns a string.
+    def erb(file, b=binding)
+      require 'erb'
+      erb = ERB.new(File.read(file))
+      erb.result b
+    end
+
+    # SSHs into the host and runs the code that has been queued.
+    #
+    # This is already automatically invoked before Rake exits to run all
+    # commands that have been queued up.
+    #
+    #     queue "sudo restart"
+    #     run!
+    #
+    def run!
+      ssh commands(:default)
+    end
+
+    # Executes a command via SSH.
+    #
+    # Options:
+    #
+    #     pretty:    Prettify the output.
+    #
+    def ssh(cmd, options={})
+      cmd = cmd.join("\n")  if cmd.is_a?(Array)
+
+      require 'shellwords'
+
+      result = 0
+      if simulate_mode
+        puts cmd
+      elsif settings.term_mode == :pretty
+        code = "#{ssh_command} -- bash -c %s" % [ Shellwords.escape("true;"+cmd) ]
+        result = pretty_system("#{code} 2>&1")
+      elsif settings.term_mode == :exec
+        code = "#{ssh_command} -t -- bash -c %s" % [ Shellwords.escape("true;"+cmd) ]
+        exec code
+      else
+        code = "#{ssh_command} -t -- bash -c %s" % [ Shellwords.escape("true;"+cmd) ]
+        system code
+        result = $?
+      end
+
+      unless result == 0
+        err = Failed.new("Failed with status #{result}")
+        err.exitstatus = result
+        raise err
+      end
+
+      result
+    end
+
+    # Returns the SSH command to be executed.
+    #
+    #     set :domain, 'foo.com'
+    #     set :user, 'diggity'
+    #     puts ssh_command
+    #     #=> 'ssh diggity@foo.com'
+    #
+    def ssh_command
+      args = domain!
+      args = "#{user}@#{args}" if user?
+      args << " -i #{identity_file}" if identity_file?
+      "ssh #{args}"
+    end
+
+    # Works like 'system', but indents and puts color.
+    # Returns the exit code in integer form.
+    def pretty_system(code)
+      status =
+        Tools.popen4('bash', '-') do |pid, i, o, e|
+          i.write "( #{code} ) 2>&1\n"
+          i.close
+
+          last = nil
+          clear_on_nl = false
+          while c = o.getc
+            # Because Ruby 1.8.x returns a number on #getc
+            c = "%c" % [c]  if c.is_a?(Fixnum)
+
+            break if o.closed?
+            if last == "\n"
+              if clear_on_nl
+                clear_on_nl = false
+                print "\033[0m"
+              end
+
+              # Color the verbose echo commands
+              if c == "$" && ((c += o.read(1)) == "$ ")
+                clear_on_nl = true
+                print " "*7 + "\033[32m#{c}\033[34m"
+
+              # (Don't) color the status messages
+              elsif c == "-" && ((c += o.read(5)) == "----->")
+                print c
+
+              # Color errors
+              elsif c == "=" && ((c += o.read(5)) == "=====>")
+                print "\033[31m=====>\033[0m"
+
+              else
+                print " "*7 + c
+              end
+            else
+              print c
+            end
+
+            last = c
+          end
+        end
+      status.exitstatus
+    end
+
+    # Queues code to be ran.
+    # This queues code to be ran to the current code bucket (defaults to `:default`).
+    # To get the things that have been queued, use commands[:default]
+    #
+    #     queue "sudo restart"
+    #     queue "true"
+    #
+    #     commands == ['sudo restart', 'true']
+    #
+    def queue(code)
+      commands
+      commands(@to) << unindent(code)
+    end
+
+    def unindent(code)
+      if code =~ /^\n([ \t]+)/
+        code = code.gsub(/^#{$1}/, '')
+      end
+
+      code.strip
+    end
+
+    # Returns a hash of the code blocks where commands have been queued.
+    #
+    #     queue "sudo restart"
+    #     queue "true"
+    #
+    #     to :clean do
+    #       queue "rm"
+    #     end
+    #
+    #     commands == ["sudo restart", "true"]
+    #     commands(:clean) == ["rm"]
+    #
+    def commands(aspect=:default)
+      (@commands ||= begin
+        @to = :default
+        Hash.new { |h, k| h[k] = Array.new }
+      end)[aspect]
+    end
+
+    # Starts a new block where new #commands are collected.
+    #
+    #     queue "sudo restart"
+    #     queue "true"
+    #     commands.should == ['sudo restart', 'true']
+    #
+    #     isolate do
+    #       queue "reload"
+    #       commands.should == ['reload']
+    #     end
+    #
+    #     commands.should == ['sudo restart', 'true']
+    #
+    def isolate(&blk)
+      old, @commands = @commands, nil
+      result = yield
+      new_code, @commands = @commands, old
+      result
+    end
+
+    # Defines instructions on how to do a certain thing.
+    # This makes the commands that are `queue`d go into a different bucket in commands.
+    #
+    #     to :prepare do
+    #       run "bundle install"
+    #     end
+    #     to :launch do
+    #       run "nginx -s restart"
+    #     end
+    #
+    #     commands(:prepare) == ["bundle install"]
+    #     commands(:restart) == ["nginx -s restart"]
+    #
+    def to(name, &blk)
+      old, @to = @to, name
+      result = yield
+      @to = old
+      result
+    end
+
+    # Sets settings.
+    #
+    #     set :domain, 'kickflip.me'
+    #
+    def set(key, value)
+      settings.send :"#{key}=", value
+    end
+
+    # Sets default settings.
+    #
+    #     set_default :term_mode, :pretty
+    #     set :term_mode, :system
+    #     settings.term_mode.should == :system
+    #
+    #     set :term_mode, :system
+    #     set_default :term_mode, :pretty
+    #     settings.term_mode.should == :system
+    #
+    def set_default(key, value)
+      settings.send :"#{key}=", value  unless settings.send(:"#{key}?")
+    end
+
+    # Accesses the settings hash.
+    #
+    #     set :domain, 'kickflip.me'
+    #     settings.domain  #=> 'kickflip.me'
+    #     domain           #=> 'kickflip.me'
+    #
+    def settings
+      @settings ||= Settings.new
+    end
+
+    # Hook to get settings.
+    # See #settings for an explanation.
+    def method_missing(meth, *args, &blk)
+      settings.send meth, *args
+    end
+
+    def indent(count, str)
+      str.gsub(/^/, " "*count)
+    end
+
+    def error(str)
+      $stderr.write "#{str}\n"
+    end
+
+    def echo_cmd(str)
+      if verbose_mode
+        "echo #{("$ " + str).inspect} &&\n#{str}"
+      else
+        str
+      end
+    end
+
+    # Invoked when Rake exits.
+    def mina_cleanup!
+      run! if commands.any?
+    end
+
+    # Checks if Rake was invoked with --verbose.
+    def verbose_mode
+      if Rake.respond_to?(:verbose)
+        # Rake 0.9.x
+        Rake.verbose == true
+      else
+        # Rake 0.8.x
+        RakeFileUtils.verbose_flag != :default
+      end
+    end
+
+    def simulate_mode
+      !! ENV['simulate']
+    end
+  end
+end

data/lib/mina/rails.rb

@@ -0,0 +1,69 @@
+settings.rails_env ||= 'production'
+# TODO: This should be lambda
+settings.bundle_prefix ||= lambda { %{RAILS_ENV="#{rails_env}" bundle exec} }
+settings.rake ||= lambda { %{#{bundle_prefix} rake} }
+settings.rails ||= lambda { %{#{bundle_prefix} rails} }
+
+# Macro used later by :rails, :rake, etc
+make_run_task = lambda { |name, sample_args|
+  task name, :arguments do |t, args|
+    command = args[:arguments]
+    unless command
+      puts %{You need to provide arguments. Try: mina "#{name}[#{sample_args}]"}
+      exit 1
+    end
+    queue %[cd "#{deploy_to!}/#{current_path!}" && #{rails} #{command}]
+  end
+}
+
+desc "Execute a Rails command in the current deploy."
+make_run_task[:rails, 'console']
+
+desc "Execute a Rake command in the current deploy."
+make_run_task[:rake, 'db:migrate']
+
+namespace :rails do
+  desc "Migrates the Rails database."
+  task :db_migrate do
+    queue %{
+      echo "-----> Migrating database"
+      #{echo_cmd %[#{rake} db:migrate]}
+    }
+  end
+
+  desc "Precompiles assets."
+  task :'assets_precompile:force' do
+    queue %{
+      echo "-----> Precompiling asset files"
+      #{echo_cmd %[#{rake} assets:precompile]}
+    }
+  end
+
+  desc "Precompiles assets (skips if nothing has changed since the last release)."
+  task :'assets_precompile' do
+    if ENV['force_assets']
+      invoke :'rails:assets_precompile:force'
+      return
+    end
+
+    queue %{
+      # Check if the last deploy has assets built, and if it can be re-used.
+      if [ -d "#{current_path}/public/assets" ]; then
+        count=`(
+          diff -r "#{current_path}/vendor/assets/" "./vendor/assets/" 2>/dev/null;
+          diff -r "#{current_path}/app/assets/" "./app/assets/" 2>/dev/null
+        ) | wc -l`
+
+        if [ "$((count))" = "0" ]; then
+          echo "-----> Skipping asset precompilation"
+          #{echo_cmd %[cp -R "#{current_path}/public/assets" "./public/assets"]} &&
+          exit
+        fi
+      fi
+
+      echo "-----> Precompiling asset files"
+      #{echo_cmd %[#{rake} assets:precompile]}
+    }
+  end
+
+end

data/lib/mina/rake.rb

@@ -0,0 +1,6 @@
+# This file is invoked from Rake.
+extend Mina::Helpers
+extend Mina::DeployHelpers
+
+require 'mina/default'
+require 'mina/deploy' if Rake.application.have_rakefile

data/lib/mina/settings.rb

@@ -0,0 +1,32 @@
+module Mina
+  class Settings < Hash
+    def method_missing(meth, *args, &blk)
+      name = meth.to_s
+
+      return evaluate(self[meth])  if name.size == 1
+
+      # Ruby 1.8.7 doesn't let you do string[-1]
+      key, suffix = name[0..-2].to_sym, name[-1..-1]
+
+      case suffix
+      when '='
+        self[key] = args.first
+      when '?'
+        include? key
+      when '!'
+        raise Error, "Setting :#{key} is not set" unless include?(key)
+        evaluate self[key]
+      else
+        evaluate self[meth]
+      end
+    end
+
+    def evaluate(value)
+      if value.is_a?(Proc)
+        value.call
+      else
+        value
+      end
+    end
+  end
+end

data/lib/mina/tools.rb

@@ -0,0 +1,14 @@
+module Mina
+  module Tools
+    if IO.respond_to?(:popen4)
+      def self.popen4(*cmd, &blk)
+        IO.popen4 *cmd, &blk
+      end
+    else
+      def self.popen4(*cmd, &blk)
+        require 'open4'
+        Open4.popen4 *cmd, &blk
+      end
+    end
+  end
+end

data/lib/mina/version.rb

@@ -0,0 +1,5 @@
+module Mina
+  def self.version
+    "0.1.0"
+  end
+end

data/mina.gemspec

@@ -0,0 +1,17 @@
+require './lib/mina/version'
+
+Gem::Specification.new do |s|
+  s.name = "mina"
+  s.version = Mina.version
+  s.summary = %{Really fast deployer and server automation tool.}
+  s.description = %Q{Builds scripts."}
+  s.authors = ["Rico Sta. Cruz", "Michael Galero"]
+  s.email = ["rico@nadarei.co", "mikong@nadarei.co"]
+  s.homepage = "http://github.com/nadarei/mina"
+  s.files = `git ls-files`.strip.split("\n")
+  s.executables = Dir["bin/*"].map { |f| File.basename(f) }
+
+  s.add_dependency "rake"
+  s.add_dependency "open4"
+  s.add_development_dependency "rspec"
+end

data/spec/command_helper.rb

@@ -0,0 +1,52 @@
+# Invokes the main 'mina' command.
+def run_command(*args)
+  out = ''
+  err = ''
+  @result = nil
+
+  if ENV['rake']
+    rake_version = "~> #{ENV['rake'] || '0.9'}.0"
+    script  = %[require 'rubygems' unless Object.const_defined?(:Gem);]
+    script += %[gem 'rake', '#{rake_version}';]
+    script += %[load '#{root('bin/mina')}']
+    cmd = ['ruby', '-e', "#{script}", "--", *args]
+  else
+    cmd = [root('bin/mina'), *args]
+  end
+
+  status =
+    Mina::Tools.popen4(*cmd) do |pid, i, o, e|
+      out = o.read
+      err = e.read
+    end
+
+  @result = status.exitstatus
+
+  @out = out
+  @err = err
+
+  @result
+end
+
+# Invokes the main 'mina' command and ensures the exit status is success.
+def mina(*args)
+  run_command *args
+  if exitstatus != 0 && ENV['verbose']
+    puts stdout
+    puts stderr
+  end
+
+  exitstatus.should == 0
+end
+
+def stdout
+  @out
+end
+
+def stderr
+  @err
+end
+
+def exitstatus
+  @result
+end