mina-traackr 0.3.0

data/lib/mina/deploy.rb

@@ -0,0 +1,138 @@
+# # Modules: Deployment
+# This module is automatically loaded for all Mina projects.
+
+# ## Settings
+# Any and all of these settings can be overriden in your `deploy.rb`.
+
+# ### releases_path
+# (default: 'releases')
+set_default :releases_path, "releases"
+
+# ### shared_path
+# (default: 'shared')
+set_default :shared_path, "shared"
+
+# ### current_path
+# (default: 'current_path')
+set_default :current_path, "current"
+
+# ### lock_file
+# Name of the file to generate while a deploy is currently ongoing.
+# (default: 'deploy.lock')
+set_default :lock_file, "deploy.lock"
+
+# ### keep_releases
+# Number of releases to keep when doing the `deploy:cleanup` task.
+# (default: 5)
+set_default :keep_releases, 5
+
+namespace :deploy do
+  # ## Tasks
+
+  # ### deploy:force_unlock
+  # Forces a deploy unlock by deleting the lock file.
+  #
+  #     $ mina deploy:force_unlock
+  #
+  # You can also combine that task with `deploy`:
+  #
+  #     $ mina deploy:force_unlock deploy
+
+  desc "Forces a deploy unlock."
+  task :force_unlock do
+    queue %{echo "-----> Unlocking"}
+    queue echo_cmd %{rm -f "#{deploy_to}/#{lock_file}"}
+  end
+
+  # ### deploy:link_shared_paths
+  # Links the shared paths in the `shared_paths` setting.
+
+  desc "Links paths set in :shared_paths."
+  task :link_shared_paths do
+    dirs = settings.shared_paths!.map { |file| File.dirname("./#{file}") }.uniq
+
+    cmds = dirs.map do |dir|
+      echo_cmd %{mkdir -p "#{dir}"}
+    end
+
+    cmds += shared_paths.map do |file|
+      [
+        echo_cmd(%{rm -rf "./#{file}"}),
+        echo_cmd(%{ln -s "#{deploy_to}/#{shared_path}/#{file}" "./#{file}"})
+      ]
+    end
+
+    queue %{
+      echo "-----> Symlinking shared paths"
+      #{cmds.flatten.join(" &&\n")}
+    }
+  end
+
+  # ### deploy:cleanup
+  # Cleans up old releases.
+  #
+  # By default, the last 5 releases are kept on each server (though you can
+  # change this with the keep_releases setting).  All other deployed revisions
+  # are removed from the servers."
+
+  desc "Clean up old releases."
+  task :cleanup do
+    queue %{
+      echo "-----> Cleaning up old releases (keeping #{keep_releases!})"
+      #{echo_cmd %{cd "#{deploy_to!}/#{releases_path!}" || exit 15}}
+      #{echo_cmd %{count=`ls -1d [0-9]* | sort -rn | wc -l`}}
+      #{echo_cmd %{remove=$((count > #{keep_releases} ? count - #{keep_releases} : 0))}}
+      #{echo_cmd %{ls -1d [0-9]* | sort -rn | tail -n $remove | xargs rm -rf {}}}
+    }
+  end
+end
+
+# ### setup
+# Sets up a site's directory structure.
+
+desc "Sets up a site."
+task :setup do
+  set_default :term_mode, :pretty
+
+  settings.deploy_to!
+
+  user = settings.user? ? "#{settings.user}" : "username"
+
+  queue %{
+    echo "-----> Setting up #{deploy_to}" && (
+      #{echo_cmd %{mkdir -p "#{deploy_to}"}} &&
+      #{echo_cmd %{chown -R `whoami` "#{deploy_to}"}} &&
+      #{echo_cmd %{chmod g+rx,u+rwx "#{deploy_to}"}} &&
+      #{echo_cmd %{cd "#{deploy_to}"}} &&
+      #{echo_cmd %{mkdir -p "#{releases_path}"}} &&
+      #{echo_cmd %{chmod g+rx,u+rwx "#{releases_path}"}} &&
+      #{echo_cmd %{mkdir -p "#{shared_path}"}} &&
+      #{echo_cmd %{chmod g+rx,u+rwx "#{shared_path}"}} &&
+      echo "" &&
+      #{echo_cmd %{ls -la "#{deploy_to}"}} &&
+      echo "" &&
+      echo "-----> Done."
+    ) || (
+      echo "! ERROR: Setup failed."
+      echo "! Ensure that the path '#{deploy_to}' is accessible to the SSH user."
+      echo "! Try doing:"
+      echo "!    sudo mkdir -p \\"#{deploy_to}\\" && sudo chown -R #{user} \\"#{deploy_to}\\""
+    )
+  }
+end
+
+# ### run[]
+# Runs a command on a server.
+#
+#     $ mina run[tail -f logs.txt]
+
+desc "Runs a command in the server."
+task :run, [:command] => [:environment] do |t, args|
+  command = args[:command]
+  unless command
+    puts %[You need to provide a command. Try: mina "run[ls -la]"]
+    exit 1
+  end
+
+  queue %[cd #{deploy_to!} && #{command}]
+end

data/lib/mina/deploy_helpers.rb

@@ -0,0 +1,34 @@
+# # Helpers: Deploy helpers
+# Helpers for deployment.
+module Mina
+  module DeployHelpers
+    # ### deploy
+    # Wraps the things inside it in a deploy script and queues it.
+    # This generates a script using deploy_script and queues it.
+    #
+    # Returns nothing.
+    #
+    def deploy(&blk)
+      queue deploy_script(&blk)
+    end
+
+    # ### deploy_script
+    # Wraps the things inside it in a deploy script.
+    #
+    #     script = deploy_script do
+    #       invoke :'git:checkout'
+    #     end
+    #
+    #     queue script
+    #
+    # Returns the deploy script as a string, ready for `queue`ing.
+    #
+    def deploy_script(&blk)
+      set_default :term_mode, :pretty
+      code = isolate do
+        yield
+        erb Mina.root_path('data/deploy.sh.erb')
+      end
+    end
+  end
+end

data/lib/mina/exec_helpers.rb

@@ -0,0 +1,104 @@
+# # Helpers: Exec helpers
+# Provides `pretty_system` which Mina uses to parse SSH output, and delegate to
+# the appropriate Output helper.
+
+module Mina
+  module ExecHelpers
+
+    # ### pretty_system
+    # __Internal:__ A pretty version of the default `#system` commands, but
+    # indents and puts color.
+    #
+    # Returns the exit code in integer form.
+    #
+    def pretty_system(code)
+      require 'shellwords'
+      cmds = Shellwords.shellsplit(code)
+      coathooks = 0
+
+      status =
+        Tools.popen4(*cmds) do |pid, i, o, e|
+          # Handle `^C`.
+          trap("INT") { Sys.handle_sigint(coathooks += 1, pid, self) }
+
+          # __In the background,__ make stdin passthru, and stream stderr.
+          pid_err = Sys.stream_stderr!(e) { |str| print_stderr str }
+          pid_in  = Sys.stream_stdin!     { |chr| i.putc chr }
+
+          # __In the foreground,__ stream stdout to the output helper.
+          Sys.stream_stdout(o) { |ch| print_char ch }
+
+          Process.waitpid pid_err
+          Process.kill 'TERM', pid_in
+        end
+
+      status.exitstatus
+    end
+
+    # ## Private methods
+    # Delegate functions, mostly.
+
+    module Sys
+
+      extend self
+
+      # ### Sys.handle_sigint!
+      # Called when a `^C` is pressed. The param `count` is how many times it's
+      # been pressed since. Returns nothing.
+
+      def handle_sigint(count, pid, this)
+        puts ""
+        if count > 1
+          this.print_status "Mina: SIGINT received again. Force quitting..."
+          Process.kill "KILL", pid
+        else
+          this.print_status "Mina: SIGINT received."
+          Process.kill "TERM", pid
+        end
+      end
+
+      # ### Sys.stream_stderr!
+      # __Internal:__ Read from stderr stream `err` *[0]*, supress expected
+      # errors *[1]*, and yield. Returns the PID.
+
+      def stream_stderr!(err, &blk)
+        fork do
+          trap("INT") {}
+
+          while str = err.gets #[0]
+            next if str.include? "bash: no job control in this shell" #[1]
+            next if str.include? "stdin is not a terminal"
+
+            yield str.strip #[2]
+          end
+        end
+      end
+
+      # ### Sys.stream_stdin!
+      # __Internal:__ Read from the real stdin stream and pass it onto the given
+      # stdin stream `i`. Returns the PID.
+
+      def stream_stdin!(&blk)
+        fork do
+          trap("INT") {}
+
+          while (char = STDIN.getbyte rescue nil)
+            yield char if char
+          end
+        end
+      end
+
+      # ### Sys.stream_stdout
+      # __Internal:__ Read from given stdout stream `o` and delegate it to the
+      # output helper.
+
+      def stream_stdout(o, &blk)
+        while str = o.getc
+          yield str
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mina/foreman.rb

@@ -0,0 +1,78 @@
+# # Modules: Foreman
+# Adds settings and tasks for managing projects with [foreman].
+#
+# NOTE: Requires sudo privileges
+#
+# [foreman]: http://rubygems.org/ddolar/foreman
+#
+#    require 'mina/foreman'
+#
+# ## Common usage
+#
+#    set :application, "app-name"
+#
+#    task :deploy => :environment do
+#      deploy do
+#        # ...
+#        invoke 'foreman:export'
+#        # ...
+#      end
+#
+#      to :launch do
+#        invoke 'foreman:restart'
+#      end
+#    end
+#
+
+# ## Settings
+# Any and all of these settings can be overriden in your `deploy.rb`.
+
+# ### foreman_app
+# Sets the service name that foreman will export to upstart. Uses *application*
+# variable as a default. It should be set, otherwise export command will fail.
+
+# ### foreman_user
+# Sets the user under which foreman will execute the service. Defaults to *user*
+
+# ### foreman_log
+# Sets the foreman log path. Defaults to *shared/log*
+
+set_default :foreman_app,  lambda { application }
+set_default :foreman_user, lambda { user }
+set_default :foreman_log,  lambda { "#{deploy_to!}/#{shared_path}/log" }
+
+namespace :foreman do
+  desc 'Export the Procfile to Ubuntu upstart scripts'
+  task :export do
+    export_cmd = "sudo bundle exec foreman export upstart /etc/init -a #{foreman_app} -u #{foreman_user} -l #{foreman_log}"
+
+    queue %{
+      echo "-----> Exporting foreman procfile for #{foreman_app}"
+      #{echo_cmd %[cd #{deploy_to!}/#{current_path!} ; #{export_cmd}]}
+    }
+  end
+
+  desc "Start the application services"
+  task :start do
+    queue %{
+      echo "-----> Starting #{foreman_app} services"
+      #{echo_cmd %[sudo start #{foreman_app}]}
+    }
+  end
+
+  desc "Stop the application services"
+  task :stop do
+    queue %{
+      echo "-----> Stopping #{foreman_app} services"
+      #{echo_cmd %[sudo stop #{foreman_app}]}
+    }
+  end
+
+  desc "Restart the application services"
+  task :restart do
+    queue %{
+      echo "-----> Restarting #{foreman_app} services"
+      #{echo_cmd %[sudo start #{foreman_app} || sudo restart #{foreman_app}]}
+    }
+  end
+end

data/lib/mina/git.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+# # Modules: Git
+# Adds settings and tasks related to managing Git.
+#
+#     require 'mina/git'
+
+# ## Settings
+# Any and all of these settings can be overriden in your `deploy.rb`.
+
+# ### branch
+# Sets the branch to be deployed.
+
+set_default :branch, 'master'
+
+namespace :git do
+  # ## Deploy tasks
+  # These tasks are meant to be invoked inside deploy scripts, not invoked on
+  # their own.
+
+  # ### git:clone
+  # Clones the Git repository. Meant to be used inside a deploy script.
+
+  desc "Clones the Git repository to the release path."
+  task :clone do
+    if revision?
+      error "The Git option `:revision` has now been deprecated."
+      error "Please use `:commit` or `:branch` instead."
+      exit
+    end
+
+    clone = if commit?
+      %[
+        echo "-----> Using git commit '#{commit}'" &&
+        #{echo_cmd %[git clone "#{repository!}" . --recursive]} &&
+        #{echo_cmd %[git checkout -b current_release "#{commit}" --force]} &&
+      ]
+    else
+      %{
+        if [ ! -d "#{deploy_to}/scm/objects" ]; then
+          echo "-----> Cloning the Git repository"
+          #{echo_cmd %[git clone "#{repository!}" "#{deploy_to}/scm" --bare]}
+        else
+          echo "-----> Fetching new git commits"
+          #{echo_cmd %[(cd "#{deploy_to}/scm" && git fetch "#{repository!}" "#{branch}:#{branch}" --force)]}
+        fi &&
+        echo "-----> Using git branch '#{branch}'" &&
+        #{echo_cmd %[git clone "#{deploy_to}/scm" . --recursive --branch "#{branch}"]} &&
+      }
+    end
+
+    status = %[
+      echo "-----> Using this git commit" &&
+      echo &&
+      #{echo_cmd %[git --no-pager log --format="%aN (%h):%n> %s" -n 1]} &&
+      #{echo_cmd %[rm -rf .git]} &&
+      echo
+    ]
+
+    queue clone + status
+  end
+end

data/lib/mina/helpers.rb

@@ -0,0 +1,383 @@
+# # Helpers
+
+module Mina
+  module Helpers
+
+    # ### invoke
+    # Invokes another Rake task.
+    #
+    # Invokes the task given in `task`. Returns nothing.
+    #
+    #     invoke :'git:clone'
+    #     invoke :restart
+    #
+    # Options:
+    #   reenable (bool) - Execute the task even next time.
+    #
+
+    def invoke(task, options = {})
+      Rake.application.invoke_task task
+      Rake::Task[task].reenable if options[:reenable]
+    end
+
+    # ### erb
+    # Evaluates an ERB block in the current scope and returns a string.
+    #
+    #     a = 1
+    #     b = 2
+    #
+    #     # Assuming foo.erb is <%= a %> and <%= b %>
+    #     puts erb('foo.erb')
+    #
+    #     #=> "1 and 2"
+    #
+    # Returns the output string of the ERB template.
+
+    def erb(file, b=binding)
+      require 'erb'
+      erb = ERB.new(File.read(file))
+      erb.result b
+    end
+
+    # ### run!
+    # 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!
+    #
+    # Returns nothing.
+
+    def run!
+      report_time { ssh commands(:default) }
+    end
+
+    # ### report_time
+    # Report time elapsed in the block.
+    # Returns the output of the block.
+    #
+    #     report_time do
+    #       sleep 2
+    #       # do other things
+    #     end
+    #
+    #     # Output:
+    #     # Elapsed time: 2.00 seconds
+
+    def report_time(&blk)
+      time, output = measure &blk
+      print_str "Elapsed time: %.2f seconds" % [time]
+      output
+    end
+
+    # ### measure
+    # Measures the time (in seconds) a block takes.
+    # Returns a [time, output] tuple.
+
+    def measure(&blk)
+      t = Time.now
+      output = yield
+      [Time.now - t, output]
+    end
+
+    # ### mina_cleanup
+    # __Internal:__ Invoked when Rake exits.
+    #
+    # Returns nothing.
+
+    def mina_cleanup!
+      run! if commands.any?
+    end
+
+    # ## Errors
+
+    # ### die
+    # Exits with a nice looking message.
+    # Returns nothing.
+    #
+    #     die 2
+    #     die 2, "Tests failed"
+
+    def die(code=1, msg=null)
+      str = "Failed with status #{code}"
+      str += " (#{msg})" if msg
+      err = Failed.new(str)
+      err.exitstatus = code
+      raise err
+    end
+
+    # ### error
+    # __Internal:__ Prints to stdout.
+    # Consider using `print_error` instead.
+
+    def error(str)
+      $stderr.write "#{str}\n"
+    end
+
+    # ## Queueing
+
+    # ### queue
+    # 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]
+    #
+    # Returns nothing.
+    #
+    #     queue "sudo restart"
+    #     queue "true"
+    #
+    #     commands == ['sudo restart', 'true']
+
+    def queue(code)
+      commands
+      commands(@to) << unindent(code)
+    end
+
+    # ### queue!
+    # Shortcut for `queue`ing a command that shows up in verbose mode.
+
+    def queue!(code)
+      queue echo_cmd(code)
+    end
+
+    # ### echo_cmd
+    # Converts a bash command to a command that echoes before execution.
+    # Used to show commands in verbose mode. This does nothing unless verbose mode is on.
+    #
+    # Returns a string of the compound bash command, typically in the format of
+    # `echo xx && xx`. However, if `verbose_mode?` is false, it returns the
+    # input string unharmed.
+    #
+    #     echo_cmd("ln -nfs releases/2 current")
+    #     #=> echo "$ ln -nfs releases/2 current" && ln -nfs releases/2 current
+
+    def echo_cmd(str)
+      if verbose_mode?
+        require 'shellwords'
+        "echo #{Shellwords.escape("$ " + str)} &&\n#{str}"
+      else
+        str
+      end
+    end
+
+    # ## Commands
+
+    # ### commands
+    # Returns an array of queued code strings.
+    #
+    # You may give an optional `aspect`.
+    #
+    # Returns an array of strings.
+    #
+    #     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
+
+    # ### isolate
+    # Starts a new block where new `commands` are collected.
+    #
+    # Returns nothing.
+    #
+    #     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
+
+    # ### in_directory
+    # Starts a new block where #commands are collected, to be executed inside `path`.
+    #
+    # Returns nothing.
+    #
+    #     in_directory './webapp' do
+    #       queue "./reload"
+    #     end
+    #
+    #     commands.should == ['cd ./webapp && (./reload && true)']
+
+    def in_directory(path, &blk)
+      isolated_commands = isolate { yield; commands }
+      isolated_commands.each { |cmd| queue "(cd #{path} && (#{cmd}))" }
+    end
+
+    # ### to
+    # Defines instructions on how to do a certain thing.
+    # This makes the commands that are `queue`d go into a different bucket in commands.
+    #
+    # Returns nothing.
+    #
+    #     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
+      yield
+    ensure
+      @to = old
+    end
+
+    # ## Settings helpers
+
+    # ### set
+    # Sets settings.
+    # Sets given symbol `key` to value in `value`.
+    #
+    # Returns the value.
+    #
+    #     set :domain, 'kickflip.me'
+
+    def set(key, value)
+      settings.send :"#{key}=", value
+    end
+
+    # ### set_default
+    # Sets default settings.
+    # Sets given symbol `key` to value in `value` only if the key isn't set yet.
+    #
+    # Returns the value.
+    #
+    #     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
+
+    # ### settings
+    # Accesses the settings hash.
+    #
+    #     set :domain, 'kickflip.me'
+    #
+    #     settings.domain  #=> 'kickflip.me'
+    #     domain           #=> 'kickflip.me'
+
+    def settings
+      @settings ||= Settings.new
+    end
+
+    # ### method_missing
+    # Hook to get settings.
+    # See #settings for an explanation.
+    #
+    # Returns things.
+
+    def method_missing(meth, *args, &blk)
+      settings.send meth, *args
+    end
+
+    # ## Command line mode helpers
+
+    # ### verbose_mode?
+    # Checks if Rake was invoked with --verbose.
+    #
+    # Returns true or false.
+    #
+    #     if verbose_mode?
+    #       queue %[echo "-----> Starting a new process"]
+    #     end
+
+    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
+
+    # ### simulate_mode?
+    # Checks if Rake was invoked with --simulate.
+    #
+    # Returns true or false.
+
+    def simulate_mode?
+      !! ENV['simulate']
+    end
+
+    # ## Internal helpers
+
+    # ### indent
+    # Indents a given code block with `count` spaces before it.
+
+    def indent(count, str)
+      str.gsub(/^/, " "*count)
+    end
+
+    # ### unindent
+    # __Internal:__ Normalizes indentation on a given string.
+    #
+    # Returns the normalized string without extraneous indentation.
+    #
+    #     puts unindent %{
+    #       Hello
+    #         There
+    #     }
+    #     # Output:
+    #     # Hello
+    #     #   There
+
+    def unindent(code)
+      if code =~ /^\n([ \t]+)/
+        code = code.gsub(/^#{$1}/, '')
+      end
+
+      code.strip
+    end
+
+    # ### reindent
+    # Resets the indentation on a given code block.
+
+    def reindent(n, code)
+      indent n, unindent(code)
+    end
+
+    # ### capture
+    # Returns the output of command via SSH.
+
+    def capture(cmd, options={})
+      ssh cmd, options.merge(:return => true)
+    end
+
+  end
+end