pike 0.0.1

data/lib/pike/env.rb

@@ -0,0 +1,129 @@
+module Pike
+	class Env
+		attr_reader \
+      :lifecycle, # Contains the lifecycle (an array of [tasks, params])
+      :variables, # Conains all environment specific variables
+      :name       # Name of the environment
+
+      # Aboslute path to the bundle executable on the remote machine
+      attr_reader :bundler_prefix
+
+
+    ##
+    ## Constructor
+    ##
+
+		def initialize(name, &block)
+			@name = name
+			@variables = {}
+      @lifecycle = []
+			DSL::Environment.load(self, &block)
+		end
+
+
+    ##
+    ## Called from the DSL to add a task to the lifecycle
+    ##
+
+    def add_task(name, params = {})
+      @lifecycle << [name, params]
+    end
+
+
+    ##
+    ## Sets some internal variables
+    ##
+
+		def prepare
+      # Set the release path
+      deploy_to = get_var(:deploy_to) + '/.pike/releases/'
+      set_var release_path: (deploy_to.gsub('//', '/') + Time.new.to_i.to_s + '/')
+      set_var root_dir: File.expand_path(Dir.pwd)
+      set_var build_dir: File.expand_path("#{Dir.pwd}/.pikebuild")
+
+      # Ensure the ssh connection works
+      SSH::Connection.connect get_var(:host), get_var(:user)
+
+      # Ensure sudo works if required
+      if get_var(:use_sudo)
+        SSH::Connection.try_sudo
+      end
+
+      # Get bundler path
+      pre = "[[ -s '/etc/profile.d/rvm.sh' ]] && source /etc/profile.d/rvm.sh"
+      @bundler_prefix = "#{pre} && "
+		end
+
+
+    ##
+    ## Runs a single task from that environment
+    ##
+		def run_single_task(name)
+			prepare
+
+			task_to_run = nil
+      lifecycle.each do |task|
+        if task[0] == name
+          task_to_run = task
+          break
+        end
+      end
+
+      if task_to_run == nil
+        Main.error("Unkown task '#{name}'")
+      else
+        run_task(task_to_run[0], task_to_run[1])
+      end
+		end
+
+
+    ##
+    ## Run the complete lifecycle of the environment
+    ##
+
+		def run_lifecycle
+			prepare
+
+			@lifecycle.each do |task|
+				run_task task[0], task[1]
+			end
+		end
+
+
+    ##
+    ## Called from the DSL to set variables
+    ##
+
+		def set_var(vars = {})
+			vars.keys.each do |key|
+				@variables[key] = vars[key]
+			end
+		end
+
+
+    ##
+    ## Returns a variables value
+    ##
+
+		def get_var(key)
+			@variables[key] || Main.get_var(key)
+		end
+
+
+    ##
+    ## Runs a task for that environment
+    ##
+
+		def run_task(name, params)
+			Main.action "# Run task #{name}" do
+				task = Main.find_task(name)
+
+				if task
+					task.run(self, params)
+				else
+					raise "Task #{name} not found"
+				end
+			end
+		end
+	end
+end

data/lib/pike/logger.rb

@@ -0,0 +1,86 @@
+module Pike
+  class Logger
+    class << self
+
+      ##
+      ## Call this if Main.get(:log_file) is finally determined
+      ##
+
+      def init
+        setup_logfile
+
+        log(@log_buffer.string) if @log_buffer
+
+        log
+        log("Timestamp: #{Time.now}")
+        log
+        log('Starting build ...')
+        log
+      end
+
+
+      ##
+      ## Logs a String or (if no param is given) a line break.
+      ## Can be called before Logger.init, then everything will be buffered and written to the
+      ## log file after it is initialized
+      ##
+
+      def log(what = ' ')
+        if @log
+          log_target = @log
+        else
+          @log_buffer = StringIO.new unless @log_buffer
+          log_target =  @log_buffer
+        end
+
+        log_target.puts "#{what}\n"
+        log_target.flush
+      end
+
+
+      ##
+      ## The banner or header for the log file containing some debug infos
+      ##
+
+      def log_banner
+        log('#######################################')
+        log('#                                     #')
+        log('#   PIKE >> Intelligent Deployments   #')
+        log('#                                     #')
+        log('#######################################')
+        log
+        log("Pike version: #{Pike::VERSION.to_s}")
+        log("Ruby version: #{RUBY_VERSION}p#{RUBY_PATCHLEVEL} on #{RUBY_PLATFORM}")
+        log
+        log('Documentation: https://github.com/phortx/pike/wiki')
+        log('Issues: https://github.com/phortx/pike')
+        log
+      end
+
+
+      ##
+      ## Closes the log file
+      ##
+
+      def close
+        @log.close if @log
+      end
+
+
+
+      private #-------------------------------------------------------------------------------------
+
+      ##
+      ## Setup the log file
+      ##
+
+      def setup_logfile
+        log_file = Main.get_var(:log_file)
+        FileUtils.mkdir_p(File.dirname(log_file))
+        FileUtils.rm_f(log_file)
+        FileUtils.touch(log_file)
+        @log = File.open(log_file, 'w')
+      end
+    end
+  end
+end

data/lib/pike/main.rb

@@ -0,0 +1,275 @@
+require 'pike/env'
+require 'pike/version'
+require 'pike/logger'
+require 'pike/ssh/connection'
+require 'pike/dsl/pikefile'
+require 'pike/dsl/task'
+require 'pike/dsl/environment'
+require 'pike/tasks/task'
+require 'pike/tasks/command'
+require 'pike/rba/builder'
+require 'fileutils'
+require 'stringio'
+
+# Main class manages the whole pike system
+
+module Pike
+	class Main
+    class << self
+      attr_accessor :debug
+
+  		attr_reader \
+  			:env, # Current environment to deploy
+
+  			# Hash of available environments
+  			:envs,
+
+  			# Hash of global variables
+  			:variables,
+
+  			# Hash with all available tasks
+  			:tasks,
+
+  			# The task the user wants to run, nil means default lifecycle for that env
+  			:task_to_run,
+
+  			# Dry run?
+  			:dry_run,
+
+        # Verbose mode?
+        :verbose
+
+
+      ##
+  		## Constructor
+      ##
+
+  		def init(options)
+  			@envs = {}
+  			@variables = {}
+  			@tasks = {}
+  			@debug = options[:debug]
+  			@task_to_run = nil
+  			@dry_run = options[:dry_run]
+        @verbose = options[:verbose]
+
+        Logger.log_banner
+
+        # Variable defaults
+        set_var ({
+          branch: :master,
+          log_file: 'log/pike.log'
+        })
+
+  			# Some pretty utf8 chars to illustrate some actions
+  			@config_char = "\u26a1"
+  			@environment_char = "\u2699"
+  		end
+
+
+      ##
+      ## Run the deployment
+      ##
+
+  		def run
+        begin
+    			# Step 1: Check if the Pikefile exists and load config
+    			load_pikefile
+
+          # step 2: Internal stuff
+          Logger.init
+
+    			# Step 3: Set environment
+    			set_environment
+
+    			# Step 4: Load tasks.rb
+    			prepare
+
+    			# Step 5: Run deployment lifecycle for the given environment
+    			run_lifecycle
+
+    			# Step 6: Close SSH connection
+    			finalize
+        rescue Exception => e
+          Main.error(e.message, e.backtrace)
+        end
+  		end
+
+
+      ##
+      ## Load Pikefile
+      ##
+
+  		def load_pikefile
+  			action "#{@config_char} Loading Pikefile" do
+  				# Check if file exists
+  				raise 'No Pikefile found' unless File.exist?(Dir.pwd + '/Pikefile')
+
+  				# Load the Pikefile
+  				DSL::Pikefile.load('Pikefile')
+  			end
+  		end
+
+
+  		##
+      ## Sets the @env variable depending on what the user provided
+      ##
+
+  		def set_environment
+  			action "#{@config_char} Check given environment" do
+  				@env = ARGV[0].to_sym
+
+  				if @envs.include?(@env)
+  					@env = @envs[@env]
+            Logger.log "Environment: #{@env.name}"
+  				else
+            Logger.log "Unknown environment #{@env}. Please check you Pikefile."
+  					raise "Unknown environment #{@env}. Please check you Pikefile."
+  				end
+
+  				if ARGV[1]
+  					@task_to_run = ARGV[1].to_sym
+            Logger.log "Task: #{@task_to_run}"
+  				end
+
+  				@env
+  			end
+  		end
+
+
+  		##
+      ## Load tasks
+      ##
+
+  		def prepare
+  			action "#{@config_char} Preparing ..." do
+          Logger.log("Loading tasks ...")
+  				DSL::Pikefile.load(File.expand_path(File.dirname(__FILE__)) + '/tasks/tasks.rb')
+
+          true
+        end
+  		end
+
+
+  		##
+      ## Run the lifecycle for the environment
+      ##
+
+  		def run_lifecycle
+  			if @task_to_run
+          Logger.log "Run task #{@task_to_run} for env '#{@env.name}'"
+  				action "#{@environment_char} Run task #{@task_to_run} for env '#{@env.name}'" do
+  					@env.run_single_task(@task_to_run)
+  				end
+  			else
+          Logger.log "Run deployment lifecycle for env '#{@env.name}'"
+  				action "#{@environment_char} Run deployment lifecycle for env '#{@env.name}'" do
+  					@env.run_lifecycle
+  				end
+  			end
+  		end
+
+
+  		##
+      ## Close ssh connection and logger
+      ##
+
+  		def finalize
+        Logger.log
+        Logger.log "Finished."
+
+        SSH::Connection.close
+        Logger.close
+  		end
+
+
+      ##
+  		## Adds one or more variables (called from DSL::Pikefile.set)
+      ##
+
+  		def set_var(vars = {})
+  			vars.keys.each do |key|
+          Logger.log "Set variable '#{key}' to '#{vars[key]}"
+  				@variables[key] = vars[key]
+  			end
+  		end
+
+
+      ##
+  		## Get value of an variable (called from DSL::Pikefile.get)
+      ##
+
+  		def get_var(key)
+  			@variables[key]
+  		end
+
+
+      ##
+  		## Add a task (called from DSL::Pikefile.task)
+      ##
+
+  		def add_task(name, &block)
+        Logger.log "Adding task '#{name}'"
+  			@tasks[name] = Task.new(name, &block)
+  		end
+
+
+      ##
+  		## Add a environment (called from DSL::Pikefile.env)
+      ##
+  		def add_env(name, &block)
+        Logger.log "Adding environment '#{name}'"
+  			@envs[name] = Env.new(name, &block)
+  		end
+
+
+      ##
+  		## Find task by name and return
+      ##
+
+  		def find_task(task)
+  			@tasks[task]
+  		end
+
+
+      ##
+  		## Wrapper for step method to set @debug
+      ##
+
+  		def action(msg, vital = true, &block)
+        begin
+          step msg, vital: vital, debug: @debug do
+              yield block
+          end
+        rescue Exception => e
+          Main.error(e.message, e.backtrace)
+        end
+  		end
+
+
+      ##
+      ## Handles an error
+      ##
+
+      def error(msg, trace = nil)
+        puts
+        puts
+        puts msg
+        puts
+
+        if @debug
+          puts trace || caller
+        end
+
+        puts
+
+        Logger.log
+        Logger.log
+        Logger.log "Error in task:"
+        Logger.log msg
+        Logger.log
+        exit 1
+      end
+    end
+  end
+end

data/lib/pike/rba/builder.rb

@@ -0,0 +1,60 @@
+require 'rubygems/package'
+require 'fileutils'
+
+module Pike
+  module RBA
+    class Builder
+      ##
+      ## Builds an .rba file
+      ##
+
+      def self.build(target_file)
+        FileUtils.touch(target_file)
+        tarfile = File.open(target_file, 'w')
+
+        tar_stream = StringIO.new
+        tar_stream = build_tar_file(tar_stream)
+        gzipped_tar_stream = gzip(tar_stream)
+
+        tarfile.write gzipped_tar_stream.string
+
+        tarfile.close
+      end
+
+
+      private
+
+      def self.build_tar_file(tarfile)
+        Gem::Package::TarWriter.new(tarfile) do |tar|
+          files = Dir.glob('**/*', File::FNM_DOTMATCH).reject! {|f| f =~ /^tmp|log/i || f =~ /^\.\.?$/ }
+
+          files.each do |file|
+            mode = File.stat(file).mode
+            relative_file = file.sub /^#{Regexp::escape(Dir.pwd)}\/?/, ''
+
+            if File.directory?(file)
+              tar.mkdir relative_file, mode
+            else
+              Logger.log "  Adding file to rba: #{file}"
+
+              tar.add_file relative_file, mode do |tf|
+                File.open(file, "rb") { |f| tf.write f.read }
+              end
+            end
+          end
+        end
+
+        return tarfile
+      end
+
+      def self.gzip(stream)
+        gzipped_stream = StringIO.new
+        z = Zlib::GzipWriter.new(gzipped_stream)
+        z.write stream.string
+        z.close
+
+        return StringIO.new gzipped_stream.string
+      end
+    end
+  end
+end

data/lib/pike/ssh/connection.rb

@@ -0,0 +1,179 @@
+require 'net/ssh/shell'
+require 'net/scp'
+require 'pike/ssh/runner'
+
+module Pike
+  module SSH
+    class Connection
+      class << self
+        # Net::SSH session
+        attr_reader :session
+
+        # Current working directory
+        attr_reader :cwd
+
+        # Host we're connected with
+        attr_reader :host
+
+        # User which was used to authenticate
+        attr_reader :user
+
+        # Current state of the connection
+        attr_reader :state
+
+        # The sudo password for that connection
+        attr_accessor :sudo_password
+
+
+        ##
+        ## Connects via ssh to target host if not already connected
+        ##
+
+        def connect(host, user)
+          @host = host
+          @user = user
+          @cwd = '~'
+
+          unless @session
+            Main.action "Connecting to #{host}" do
+              begin
+                @session = ::Net::SSH.start(@host, @user)
+                wait!
+                true
+              rescue Exception => e
+                Main.error(e.inspect)
+              end
+            end
+          end
+        end
+
+
+        ##
+        ## Try's sudo to ensure the password prompt will not pop again
+        ##
+
+        def try_sudo
+          if @session
+            Main.action "Trying sudo" do
+              result = run("sudo echo 'ok'")
+
+              if result.success?
+                if result.stdout.strip.end_with?('ok')
+                  true
+                else
+                  Main.error('Unexpected data received while trying sudo: ' + result.stderr)
+                end
+              else
+                Main.error('sudo failed. Wrong password?')
+              end
+            end
+
+            false
+          else
+            connection_error
+          end
+        end
+
+
+        ##
+        ## Copies a file via scp to the remote server
+        ##
+
+        def scp(local, remote, host)
+          if ready?
+            Logger.log "Uploading file #{local} to #{host}:#{remote} ..."
+
+            begin
+              @session.scp.upload!(File.expand_path(local), remote)
+            rescue Exception => e
+              Main.error('Something went wrong with scp.', e)
+            end
+          else
+            connection_error
+          end
+        end
+
+
+        ##
+        ## Executes a command
+        ##
+
+        def run(cmd)
+          connection_error unless ready?
+          Runner.run(self, cmd)
+        end
+
+
+        ##
+        ## Closes the connection
+        ##
+
+        def close
+          if @session
+            begin
+              @session.close
+            rescue
+            end
+          end
+        end
+
+
+        ##
+        ## Wait method, wrapper for Net::SSH::Session.loopt
+        ##
+
+        def wait!
+          @session.loop
+        end
+
+
+        ##
+        ## Checks if the class is ready to run commands
+        ##
+
+        def ready?
+          @session != nil
+        end
+
+
+
+        ##
+        ## Changes the woring directory
+        ##
+
+        def cd(new_cwd)
+          prc = run("cd #{new_cwd}")
+
+          if prc.success?
+            @cwd = new_cwd
+          else
+            Main.error("Can't change workind directory: #{new_cwd} (#{prc.stderr.strip})")
+          end
+        end
+
+
+        ##
+        ## Wrapper for Session.open_channel
+        ##
+
+        def open_channel(&method)
+          @session.open_channel &method
+        end
+
+
+
+
+        private
+
+
+        ##
+        ## Error for unestablished connections
+        ##
+
+        def connection_error
+          Main.error('SSH connection is not ready yet. Call Pike::SSH::Connection.connect first.')
+        end
+      end
+    end
+  end
+end