pike 0.0.1

data/lib/pike/ssh/process.rb

@@ -0,0 +1,34 @@
+module Pike
+  module SSH
+    class Process
+      attr_accessor :stdout
+      attr_accessor :stderr
+      attr_accessor :exit_code
+      attr_accessor :command
+
+
+      def initialize(command)
+        @stdout = ''
+        @stderr = ''
+        @exit_code = 0
+        @command = command
+      end
+
+      def on_exit_status(channel, data)
+        @exit_code = data.read_long
+      end
+
+      def on_stderr(channel, type, data)
+        @stderr << data
+      end
+
+      def on_stdout(channel, data)
+        @stdout << data
+      end
+
+      def success?
+        exit_code == 0
+      end
+    end
+  end
+end

data/lib/pike/ssh/runner.rb

@@ -0,0 +1,115 @@
+require 'pike/ssh/process'
+
+module Pike
+  module SSH
+    class Runner
+      SUDO_PATTERN = /\[sudo\] password for .+:\s*$/
+
+
+      ##
+      ## Constructor
+      ##
+
+      def initialize(connection, cmd)
+        @cmd = cmd
+        @process = SSH::Process.new(@cmd)
+        @connection = connection
+        @state = :init
+      end
+
+
+      ##
+      ## Executes the process of the current Runner instance
+      ##
+
+      def run!
+        @connection.open_channel &method(:run)
+        @connection.wait!
+
+        return @process
+      end
+
+
+      ##
+      ## Simple method to run commands on a connection
+      ##
+
+      def self.run(connection, cmd)
+        ins = self.new connection, cmd
+        ins.run!
+      end
+
+      private
+
+
+
+      ##
+      ## Get's called if a channel is opened and executes the command
+      ##
+
+      def run(channel)
+        channel.request_pty
+
+        channel.exec("cd #{@connection.cwd} && (#{@cmd})") do |ch, success|
+          Main.error("Could not run command #{@cmd}") unless success
+
+          channel.on_request("exit-status", &@process.method(:on_exit_status))
+          channel.on_extended_data(&@process.method(:on_stderr))
+          channel.on_data(&method(:on_data))
+        end
+      end
+
+
+      ##
+      ## Wrapper method to catch sudo password prompt and handle it
+      ##
+
+      def on_data(channel, data)
+        handle_sudo_response(channel, data) if @state == :try_sudo
+
+        if data =~ SUDO_PATTERN
+          handle_sudo(channel, data)
+        else
+          @state = :sudo_successful
+          @process.on_stdout(channel, data)
+          channel.on_data(&@process.method(:on_stdout))
+        end
+      end
+
+
+      ##
+      ## Handles the response of the sudo command
+      ##
+
+      def handle_sudo_response(channel, data)
+        if data == 'ok'
+          @state = :sudo_successful
+        elsif data =~ /^\s+$/
+          @connection.wait!
+        elsif data =~ /incorrect password attempts\s*$/
+          Main.error("Too much incorrect password attempts")
+        elsif data =~ SUDO_PATTERN
+          # Wrong sudo password
+          @connection.sudo_password = nil
+          handle_sudo(channel, data)
+        end
+      end
+
+
+      ##
+      ## Handles a sudo password prompt by sending the password
+      ##
+
+      def handle_sudo(channel, data, wrong = false)
+        @state = :try_sudo
+
+        unless @connection.sudo_password
+          text = wrong ? "Wrong password. Please try again:" : "Please enter sudo password:"
+          @connection.sudo_password = retrieve(text) { |q| q.echo = false }
+        end
+
+        channel.send_data "#{@connection.sudo_password}\n"
+      end
+    end
+  end
+end

data/lib/pike/tasks/command/local.rb

@@ -0,0 +1,35 @@
+module Pike
+  module Tasks
+    class Command
+      class Local
+        def initialize(task)
+          @task = task
+        end
+
+        def run(cmd)
+          re = `#{cmd} 2>&1`
+
+          Logger.log re
+
+          if $? != 0
+            Main.error(re)
+          end
+
+          re
+        end
+
+        def cd(new_cwd)
+          begin
+            return Dir.chdir new_cwd
+          rescue Exception => e
+            Main.error(e)
+          end
+        end
+
+        def bundler(cmd, var_string, do_not_use)
+          run("#{var_string} bundle #{cmd}")
+        end
+      end
+    end
+  end
+end

data/lib/pike/tasks/command/remote.rb

@@ -0,0 +1,31 @@
+module Pike
+  module Tasks
+    class Command
+      class Remote
+        def initialize(task)
+          @task = task
+        end
+
+        def run(cmd)
+          prc = Pike::SSH::Connection.run(cmd)
+
+          if prc.success?
+            Logger.log prc.stdout
+            Logger.log prc.stderr
+            return prc.stdout + prc.stderr
+          else
+            Main.error("Error while executing #{cmd}: " + prc.stdout + prc.stderr)
+          end
+        end
+
+        def cd(new_cwd)
+          return Pike::SSH::Connection.cd(new_cwd)
+        end
+
+        def bundler(cmd, var_string, sudo = false)
+          run("#{@task.current_env.bundler_prefix} #{sudo ? 'sudo ' : ''} #{var_string} bundle #{cmd}")
+        end
+      end
+    end
+  end
+end

data/lib/pike/tasks/command.rb

@@ -0,0 +1,150 @@
+require 'pike/tasks/command/local'
+require 'pike/tasks/command/remote'
+
+module Pike
+  module Tasks
+  	class Command
+  		attr_reader \
+        :where, # :local || :remote - Determines on which machine to run the command
+        :cmd,   # The command string
+        :mode   # :cd, :cmd, :bundler, :scp, :build_rba # TODO move those? polymorphism?
+        :vars   # Hash of vars
+
+
+      ##
+      ## Constructor
+      ##
+
+  		def initialize(task, where, cmd, vars = {})
+        @task = task
+  			@where = where
+        @vars = vars
+
+        case cmd.split(' ').first
+        when 'cd'
+          @mode = :cd
+          @cd_to = cmd.gsub('cd ', '')
+
+        when 'bundle'
+          @mode = :bundler
+          @cmd = cmd.gsub('bundle ', '')
+
+        when '!BUILD_RBA'
+          @mode = :build_rba
+          @cmd = nil
+
+        when '!SCP'
+          @mode = :scp
+
+          splitted = cmd.gsub('!SCP ', '').split(' ')
+          @local = splitted[0]
+          @remote = splitted[1]
+
+        else
+          @mode = :cmd
+  			  @cmd = cmd
+        end
+  		end
+
+
+      ##
+      ## The cmd prefix for the log. Looks like a bash prompt
+      ##
+
+      def get_cmd_prefix
+        "\n" + (where == :local ? Dir.pwd : SSH::Connection.cwd) + " (#{where})$  #{to_s}"
+      end
+
+
+      ##
+      ## Runs the command
+      ##
+
+      def run(env)
+        # Log command
+        Logger.log get_cmd_prefix
+        report("#{where == :remote ? '>' : '<'} #{to_s}") if Main.verbose
+
+        # Determine target environment
+        target = (where == :local ? Local.new(@task) : Remote.new(@task))
+
+        unless Main.dry_run
+          # Mode depending routines
+          case @mode
+          when :cmd
+            return target.run("#{var_string} #{sudo}#{@cmd}")
+
+          when :cd
+            return target.cd(@cd_to)
+
+          when :bundler
+            return target.bundler(@cmd, var_string, sudo?)
+
+          when :build_rba
+            return build_rba
+
+          when :scp
+            SSH::Connection.scp(@local, @remote, env.get_var(:host))
+
+          else
+            Main.error("Unkown command mode #{@mode}")
+          end
+        end
+      end
+
+
+      ##
+      ## Generates the vars for the shell command
+      ##
+
+      def var_string
+        re = ''
+        @vars.each do |key, value|
+          re << "#{key.to_s.upcase.strip}=#{value} "
+        end
+        re
+      end
+
+
+      ##
+      ## Starts the build process for .rba file
+      ##
+
+      def build_rba
+        target_file = '../' + Main.get_var(:name) + '.rba'
+        Logger.log "Building RBA file: #{target_file} ..."
+        RBA::Builder.build(target_file)
+        target_file
+      end
+
+
+      ##
+      ## Converts command to string. Depending on the mode, the result may differ
+      ##
+
+      def to_s
+        case @mode
+        when :cmd
+          "#{sudo}#{var_string}#{@cmd}"
+        when :bundler
+          "#{sudo}#{var_string}bundle #{@cmd}"
+        when :cd
+          "cd #{@cd_to}"
+        when :scp
+          "scp #{@local} #{@remote}"
+        when :build_rba
+          "build .rba file"
+        end
+      end
+
+
+      def sudo
+        sudo? ? 'sudo ' : ''
+      end
+
+      def sudo?
+        where == :remote && @task.current_env.get_var(:use_sudo) && !@cmd.strip.start_with?('source ')
+      end
+  	end
+  end
+end

data/lib/pike/tasks/task.rb

@@ -0,0 +1,125 @@
+module Pike
+  class Task
+    attr_accessor :current_env
+
+    ##
+    ## Constructor
+    ##
+
+    def initialize(name, &block)
+      @block = block
+      @current_env = nil
+      @current_params = {}
+      @name = name
+    end
+
+
+    ##
+    ## Call run that task
+    ##
+
+    def run(env, params)
+      log_header
+
+      # Setting @current_params and @current_env
+      set_current_params params
+      @current_env = env
+
+      # Parse the task block
+      DSL::Task.load(self, &@block)
+    end
+
+
+    ##
+    ## Called from the DSL to run another task
+    ##
+
+    def run_task(task)
+      @current_env.run_task(task)
+    end
+
+
+    ##
+    ## Called from the DSL to get the value of a varaible
+    ##
+
+    def get_var(key, default = nil)
+      return @current_env.get_var(key) if var_given?(key)
+      return default if default
+      undef_error(:variable, key)
+    end
+
+
+
+    ##
+    ## Called from the DSL to get the value of a param
+    ##
+
+
+    def get_param(key, default = nil)
+      return @current_params[key] if param_given?(key)
+      return default if default
+      undef_error(:param, key)
+    end
+
+
+    ##
+    ## Checks if a param with the given key is defined
+    ##
+
+    def param_given?(key)
+      @current_params.include?(key)
+    end
+
+
+    ##
+    ## Checks if a variable with the given key is defined
+    ##
+
+    def var_given?(key)
+      (@current_env.get_var(key) != nil)
+    end
+
+
+
+    private
+
+
+    ##
+    ## Log header for that task
+    ##
+
+    def log_header
+      Logger.log
+      Logger.log
+      Logger.log "  Run Task: #{@name}"
+      Logger.log "==============" + @name.length.times.collect { '=' }.join
+      Logger.log
+    end
+
+
+    ##
+    ## Iterates over all params, adds them to @current_params and logs them
+    ##
+
+    def set_current_params(params)
+      @current_params = params
+
+      @current_params.keys.each do |key|
+        Logger.log "Option '#{key}': #{@current_params[key]}"
+      end
+
+      Logger.log
+    end
+
+
+
+    ##
+    ## Throw error if param or variable is not defined
+    ##
+
+    def undef_error(type, key)
+      Main.error("Require the #{type} #{key} for the task #{@name} but it's not defined.")
+    end
+  end
+end

data/lib/pike/tasks/tasks.rb

@@ -0,0 +1,168 @@
+# TODO the order of the tasks may vary. So make sure every tasks cds in his required directory
+
+task :clone do
+  local "rm -rf #{get :build_dir}"
+
+  branch = param(:branch, 'master')
+  depth = param(:depth, 1)
+
+	local "git clone --depth=#{depth} -b #{branch} #{param :repository} #{get :build_dir}"
+  local "cd #{get :build_dir}"
+end
+
+task :submodules do
+  local "cd #{get :build_dir}"
+  local "git submodule update --init"
+end
+
+task :reduce do
+  local "cd #{get :build_dir}"
+  local 'rm -rf ' + param(:clean).join(' ')
+end
+
+task :bundle do
+  local "cd #{get :build_dir}"
+  without = param_given?(:without) ? '--without ' + param(:without).join(' ') : ''
+  local "bundle install #{without}"
+end
+
+task :rspec do
+  local "cd #{get :build_dir}"
+  local "bundle exec rspec"
+end
+
+task :assets do
+  local "cd #{get :build_dir}"
+  vars = { RAILS_ENV: param(:rails_env, 'development') }
+  vars[:RAILS_GROUPS] = param(:rails_group) if param_given?(:rails_group)
+
+  local "bundle exec rake assets:precompile", vars
+end
+
+task :build do
+  local "cd #{get :build_dir}"
+  local build_rba
+  local "cd #{get :root_dir}"
+
+  unless param_given?(:keep_build_dir) && param(:keep_build_dir) == true
+    local "rm -rf #{get :build_dir}"
+  end
+end
+
+
+# Directory sturcture:
+# - /opt/jarvis
+#   - config/
+#     - config.yml
+#   - db/
+#     - jarvis.sqlite3
+#   - config.ru
+#   - .pike
+#     - releases/
+#       - 123/
+#         - app
+#         - config/
+#           - (s) config.yml -> ../../../../config/config.yml
+#         - db/
+#           - (s) jarvis.sqlite3 -> ../../../../db/jarvis.sqlite3
+#     - (s) current -> releases/123
+#     - (s) assets -> current/public/assets
+#     - (s) index.html -> current/public/index.html
+
+task :deploy do
+  name = get(:name)
+  deploy_to = get(:deploy_to)
+  target_dir = get(:release_path)
+
+  local "cd #{get :root_dir}"
+
+  # Copy the rba file to the server in the /tmp directory
+  upload "#{name}.rba", "/tmp/#{name}.rba"
+
+  # Create dir /path/to/deploy/.rba/releases/timestamp/
+  remote "mkdir -pv #{target_dir}"
+
+  # Move the .rba file to the release directory
+  remote "mv -vf /tmp/#{name}.rba #{target_dir}"
+
+  # CD into the release directory
+  remote "cd #{target_dir}"
+
+  # Extract the rba file
+  remote "tar -xzvf #{name}.rba"
+
+  # Remove the rba file
+  remote "rm -vf #{name}.rba"
+
+  # Make sure tmp/pids exists
+  remote "mkdir -pv tmp/pids"
+end
+
+
+task :symlink_shared do
+  remote "cd #{get :deploy_to}"
+
+	param(:files).each do |file|
+    remote "ln -nfvs #{get :deploy_to}#{file} #{get :release_path}#{file}"
+	end
+end
+
+task :symlinks do
+  remote "cd #{get :deploy_to}"
+
+  # Current release link
+	remote "ln -nfvs #{get :release_path} #{get :deploy_to}.pike/current"
+
+  # public/ files
+  files = remote "ls -lAh #{get :release_path}public | awk -F ' ' '{print $9}'"
+
+  files.split("\n").each do |file|
+    file.strip!
+    if file != ''
+      remote "ln -nfvs #{get :deploy_to}.pike/current/public/#{file} #{get :deploy_to}.pike/#{file}"
+    end
+  end
+end
+
+task :bundle_deployment do
+  remote "cd #{get :release_path}"
+  without = param_given?(:without) ? '--without ' + param(:without).join(' ') : ''
+  no_cache = param_given?(:no_cache) && param(:no_cache) == true ? '--no-cache' : ''
+  remote "bundle install --deployment #{without} #{no_cache}"
+end
+
+task :migrate do
+  remote "cd #{get :release_path}"
+  remote "bundle exec rake db:migrate", RAILS_ENV: get(:rails_env)
+end
+
+task :cleanup do
+  remote "cd #{get :release_path}"
+
+  releases = remote "ls -lAh #{get :deploy_to}.pike/releases/ | awk -F ' ' '{print $9}'"
+  releases = releases.split("\n").find_all { |r| r.strip =~ /^\d+$/ }.map { |r| r.strip }
+
+  i = 0
+  delete = releases.length - param(:keep_releases).to_i
+
+  releases.each do |release|
+    i += 1
+    remote "rm -rf  #{get :deploy_to}.pike/releases/#{release}" if i < delete
+  end
+end
+
+task :chown do
+	remote "chown -R #{param :user}:#{param :group} #{get :deploy_to}"
+end
+
+task :restart do
+	if param(:server) == :passenger
+		remote "touch #{get :release_path}tmp/restart.txt"
+	else
+		raise "Unsupported server type #{param :server}. Feel free to contribute and add support for that server! :)"
+	end
+end
+
+task :setup do
+	remote "mkdir -p #{get :deploy_to}/.pike/releases"
+end

data/lib/pike/version.rb

@@ -0,0 +1,3 @@
+module Pike
+  VERSION = "0.0.1"
+end

data/lib/pike.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'optparse'
+require 'steps'
+require 'pike/main'
+
+
+# Command line options
+options = {
+	debug: false,
+	dry_run: false,
+  verbose: false
+}
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = 'Usage: pike [OPTIONS] [ENVIRONMENT] [TASK]'
+  opt.separator ''
+  opt.separator 'Options'
+
+  opt.on('-d', '--debug', 'Enable stacktrace output.') do
+    options[:debug] = true
+  end
+
+  opt.on('-v', '--verbose', 'Enable verbosity: Executed command will be display.') do
+    options[:verbose] = true
+  end
+
+  opt.on('-s', '--simulate', 'Dry run: Simulate and don\'t really execute the commands.') do
+    options[:dry_run] = true
+  end
+
+  opt.on('-h', '--help', 'Displays help text') do
+    puts opt_parser
+    exit
+  end
+
+  opt.on('-V', '--version', 'Displays version') do
+    puts Pike::VERSION.to_s
+    exit
+  end
+end
+
+opt_parser.parse!
+
+
+# Check for environment and set default
+unless ARGV[0]
+	ARGV.push('production')
+end
+
+
+# Initialize pike
+Pike::Main.init options
+
+
+# Start the magic!
+Pike::Main.run