avodeploy 0.4.2 → 0.5

data/lib/avodeploy/task/remote_task_execution_environment.rb

@@ -17,98 +17,94 @@
 =end
 
 module AvoDeploy
-	module Task
-		class RemoteTaskExecutionEnvironment < TaskExecutionEnvironment
-
-			attr_accessor :config
-
-			# Creates a connection between the local and the remote system over ssh
-			def establish_connection
-				AvoDeploy::Deployment.instance.log.info "connecting to #{get(:user)}@#{get(:host)}..."
-
-				begin
-					@session = ::Net::SSH.start(get(:host), get(:user))
-				rescue ::Net::SSH::AuthenticationFailed => e
-					handle_abort e
-				end
-			end
-
-			# Checks, if all utilities are available for the deployment process
-			# to be executed
-			#
-			# @param utils [Array] array with utilities to check
-			def check_util_availability(utils)
-				super(utils, 'remotely')
-			end
-
-			# Executes a command via ssh
-			# 
-			# @param ssh [Net::SSH::Connection::Session] ssh session
-			# @param command [String] the command to execute
-			def ssh_exec!(ssh, command)
-			  stdout_data = ""
-			  stderr_data = ""
-			  exit_code = nil
-			  exit_signal = nil
-			  ssh.open_channel do |channel|
-			    channel.exec(command) do |ch, success|
-			      unless success
-			        abort "FAILED: couldn't execute command (ssh.channel.exec)"
-			      end
-			      channel.on_data do |ch,data|
-			        stdout_data+=data
-			      end
-
-			      channel.on_extended_data do |ch,type,data|
-			        stderr_data+=data
-			      end
-
-			      channel.on_request("exit-status") do |ch,data|
-			        exit_code = data.read_long
-			      end
-
-			      channel.on_request("exit-signal") do |ch, data|
-			        exit_signal = data.read_long
-			      end
-			    end
-			  end
-			  ssh.loop
-
-				result = AvoDeploy::CommandExecutionResult.new
-				result.stdin = command
-				result.stdout = stdout_data
-				result.stderr = stderr_data
-				result.retval = exit_code
-
-			  result
-			end
-
-			# Executes a command on the remote system
-			#
-			# @param cmd [String] the command to execute
-			# @return [CommandExecutionResult] result of the command exection
-			def command(cmd)
-				AvoDeploy::Deployment.instance.log.info "Executing [" + cmd.yellow + "] on remote " + get(:name).to_s.cyan
-
-				result = AvoDeploy::CommandExecutionResult.new
-
-				begin
-					result = ssh_exec!(@session, cmd)
-					
-					if result.stdout.nil? == false && result.stdout.empty? == false
-						AvoDeploy::Deployment.instance.log.debug "Stdout@#{get(:host)}: ".cyan + result.stdout.green
-					end
-
-					if result.stderr.nil? == false && result.stderr.empty? == false
-						AvoDeploy::Deployment.instance.log.debug "Stderr@#{get(:host)}: ".cyan + result.stderr.red
-					end
-				rescue Exception => e
-					handle_abort e
-				end
-
-				result
-			end
-
-		end
-	end
+  module Task
+    class RemoteTaskExecutionEnvironment < TaskExecutionEnvironment
+
+      attr_accessor :config
+
+      # Creates a connection between the local and the remote system over ssh
+      def establish_connection
+        AvoDeploy::Deployment.instance.log.debug "connecting to #{get(:user)}@#{get(:host)}..."
+
+        begin
+          @session = ::Net::SSH.start(get(:host), get(:user), port: get(:port), timeout: 30)
+        rescue ::Net::SSH::AuthenticationFailed => e
+          handle_abort e
+        end
+      end
+
+      # Checks, if all utilities are available for the deployment process
+      # to be executed
+      #
+      # @param utils [Array] array with utilities to check
+      def check_util_availability(utils)
+        super(utils, 'remotely')
+      end
+
+      # Executes a command via ssh
+      #
+      # @param ssh [Net::SSH::Connection::Session] ssh session
+      # @param command [String] the command to execute
+      def ssh_exec!(ssh, command)
+        stdout_data = ""
+        stderr_data = ""
+        exit_code = nil
+
+        ssh.open_channel do |channel|
+          channel.exec(command) do |ch, success|
+            unless success
+              abort "FAILED: couldn't execute command (ssh.channel.exec)"
+            end
+            channel.on_data do |ch, data|
+              stdout_data+=data
+            end
+
+            channel.on_extended_data do |ch, type, data|
+              stderr_data+=data
+            end
+
+            channel.on_request("exit-status") do |ch, data|
+              exit_code = data.read_long
+            end
+          end
+        end
+        ssh.loop
+
+        result = AvoDeploy::CommandExecutionResult.new
+        result.stdin = command
+        result.stdout = stdout_data
+        result.stderr = stderr_data
+        result.retval = exit_code
+
+        result
+      end
+
+      # Executes a command on the remote system
+      #
+      # @param cmd [String] the command to execute
+      # @return [CommandExecutionResult] result of the command exection
+      def command(cmd)
+        AvoDeploy::Deployment.instance.log.info "Executing [" + cmd.yellow + "] on remote " + get(:name).to_s.cyan
+
+        result = AvoDeploy::CommandExecutionResult.new
+
+        begin
+          result = ssh_exec!(@session, cmd)
+
+          if result.stdout.nil? == false && result.stdout.empty? == false
+            AvoDeploy::Deployment.instance.log.debug "Stdout@#{get(:host)}: ".cyan + result.stdout.green
+          end
+
+          if result.stderr.nil? == false && result.stderr.empty? == false
+            AvoDeploy::Deployment.instance.log.debug "Stderr@#{get(:host)}: ".cyan + result.stderr.red
+          end
+        rescue Exception => e
+          handle_abort e
+        end
+
+        result
+      end
+
+    end
+  end
 end

data/lib/avodeploy/task/task.rb

@@ -17,60 +17,71 @@
 =end
 
 module AvoDeploy
-	module Task
-		class Task
+  module Task
+    class Task
 
-			attr_accessor :name
-			attr_accessor :scope
-			attr_accessor :visibility
-			attr_accessor :block
-			attr_accessor :desc
+      attr_accessor :name
+      attr_accessor :scope
+      attr_accessor :visibility
+      attr_accessor :block
+      attr_accessor :desc
+      attr_accessor :remote_only
+      attr_accessor :remote_except
 
-			# Creates a new task from a task block in the deployment configuration process
-			# 
-			# @param name [Symbol] name of the task
-			# @param options [Hash] command options
-			# @param block [Block] code block of the task
-			# @return [Task] the task instance
-			def self.from_task_block(name, options, &block)
-				instance = self.new
+      # Creates a new task from a task block in the deployment configuration process
+      #
+      # @param name [Symbol] name of the task
+      # @param options [Hash] command options
+      # @param block [Block] code block of the task
+      # @return [Task] the task instance
+      def self.from_task_block(name, options, &block)
+        instance = self.new
 
-				instance.name = name
-				instance.block = block
+        instance.name = name
+        instance.block = block
 
-				instance.scope = :local
+        instance.scope = :local
 
-				if options.has_key?(:scope) && options[:scope] == :remote
-					instance.scope = :remote
-				end
+        if options.has_key?(:scope) && options[:scope] == :remote
+          instance.scope = :remote
+        end
 
-				instance.visibility = :public
+        instance.visibility = :public
 
-				if options.has_key?(:visibility) && options[:visibility] == :private
-					instance.visibility = :private
-				end
+        if options.has_key?(:visibility) && options[:visibility] == :private
+          instance.visibility = :private
+        end
 
-				if options.has_key?(:desc)
-					instance.desc = options[:desc]
-				end
+        if options.has_key?(:desc)
+          instance.desc = options[:desc]
+        end
 
-				instance
-			end
+        if options.has_key?(:only)
+          instance.remote_only = options[:only]
+        end
 
-			# Runs the code of a task
-			#
-			# @param env [TaskExecutionEnvironment] the environment to invoke the task in
-			# @return [mixed] result of the code block
-			def invoke(env)
-				raise ArgumentError 'env must be a valid TaskExecutionEnvironment' unless env.kind_of?(TaskExecutionEnvironment)
+        if options.has_key?(:except)
+          instance.remote_except = options[:except]
+        end
 
-				avo = AvoDeploy::Deployment.instance
+        instance
+      end
 
-				avo.log.debug "Running task #{@name}"
+      # Runs the code of a task
+      #
+      # @param env [TaskExecutionEnvironment] the environment to invoke the task in
+      # @param options [Hash] a hash contining additional options
+      # @return [mixed] result of the code block
+      def invoke(env, options = {})
+        raise ArgumentError 'env must be a valid TaskExecutionEnvironment' unless env.kind_of?(TaskExecutionEnvironment)
 
-				env.instance_eval(&@block)
-			end
+        avo = AvoDeploy::Deployment.instance
 
-		end
-	end
+        avo.log.debug "Running task #{@name}"
+
+        env.instance_eval(&@block)
+      end
+
+    end
+  end
 end

data/lib/avodeploy/task/task_dependency.rb

@@ -18,10 +18,10 @@
 
 module AvoDeploy
   module Task
-  	class TaskDependency
-  		attr_accessor :task_name
-  		attr_accessor :dependent_task_name
-  		attr_accessor :type
-  	end
+    class TaskDependency
+      attr_accessor :task_name
+      attr_accessor :dependent_task_name
+      attr_accessor :type
+    end
   end
 end

data/lib/avodeploy/task/task_execution_environment.rb

@@ -17,72 +17,83 @@
 =end
 
 module AvoDeploy
-	module Task
-		class TaskExecutionEnvironment
+  module Task
+    class TaskExecutionEnvironment
 
-			# Initialized the environment
-			#
-			# @param config [Hash] deployment configuration
-			def initialize(config)
-				# @todo check
-				@config = config
-			end
+      attr_accessor :scm
+      attr_accessor :options
 
-			# Assigns the scm provider
-			#
-			# @param scm_provider [ScmProvider] the scm provider to assign
-			def scm_provider=(scm_provider)
-				@scm = scm_provider
-			end
+      # Initialized the environment
+      #
+      # @param config [Hash] deployment configuration
+      def initialize(config)
+        # @todo check
+        @config = config
+      end
 
-			# Checks, if all utilities are available for the deployment process
-			# to be executed
-			#
-			# @param utils [Array] array with utilities to check
-			def check_util_availability(utils, system_name)
-				begin
-					utils.each do |util|
-						if command("command -v #{util} >/dev/null 2>&1 || exit 1;").retval == 1
-							msg = "command line utility '#{util}' is not installed #{system_name}"
+      # Runs a task without dependencies
+      #
+      # @param task_name [Symbol] task name to execute
+      # @return [Object] the task result
+      def run_nodeps(task_name)
+        AvoDeploy::Deployment.instance.task_manager.invoke_task_oneshot(task_name)
+      end
 
-							raise RuntimeError, msg
-						end
-					end
-				rescue Exception => e
-					handle_abort e
-				end
-			end
+      # Runs a task chain
+      #
+      # @param task_name [Symbol] task name to invoke
+      def run(task_name)
+        AvoDeploy::Deployment.instance.task_manager.invoke_task_chain_containing(task_name)
+      end
 
-			# Returns the logger instance
-			# 
-			# @return [Logger] log instance
-			def log
-				AvoDeploy::Deployment.instance.log
-			end
+      # Checks, if all utilities are available for the deployment process
+      # to be executed
+      #
+      # @param utils [Array] array with utilities to check
+      def check_util_availability(utils, system_name)
+        begin
+          utils.each do |util|
+            if command("command -v #{util} >/dev/null 2>&1 || exit 1;").retval == 1
+              msg = "command line utility '#{util}' is not installed #{system_name}"
 
-			# Sets a configuration item
-			#
-			# @param key [Symbol] configuration key
-			# @param value [mixed] configuration value
-			def set(key, value)
-				@config[key] = value
-			end
+              raise RuntimeError, msg
+            end
+          end
+        rescue Exception => e
+          handle_abort e
+        end
+      end
 
-			# Returns a configuration item if set
-			#
-			# @param key [Symbol] configuration key
-			# @return [mixed] configuration value
-			def get(key)
-				@config[key]
-			end
+      # Returns the logger instance
+      #
+      # @return [Logger] log instance
+      def log
+        AvoDeploy::Deployment.instance.log
+      end
 
-			# Shorthand for exception handling
-			# 
-			# @param e [Exception] the exception to handle
-			def handle_abort(e)
-				AvoDeploy::Deployment.instance.handle_abort(e)
-			end
+      # Sets a configuration item
+      #
+      # @param key [Symbol] configuration key
+      # @param value [mixed] configuration value
+      def set(key, value)
+        @config[key] = value
+      end
 
-		end
-	end
+      # Returns a configuration item if set
+      #
+      # @param key [Symbol] configuration key
+      # @return [mixed] configuration value
+      def get(key)
+        @config[key]
+      end
+
+      # Shorthand for exception handling
+      #
+      # @param e [Exception] the exception to handle
+      def handle_abort(e)
+        AvoDeploy::Deployment.instance.handle_abort(e)
+      end
+
+    end
+  end
 end