capistrano_sentinel 0.0.1

data/lib/capistrano_sentinel/helpers/actor.rb

@@ -0,0 +1,52 @@
+require_relative './application_helper'
+module CapistranoSentinel
+  module AsyncActor
+    include CapistranoSentinel::ApplicationHelper
+
+    Context = Struct.new(:method, :args, :block)
+
+    Async = Struct.new(:instance, :mailbox) do
+      extend Forwardable
+      def_delegator :instance, :respond_to?
+
+      private :instance
+      private :mailbox
+
+      def initialize(instance, mailbox)
+        super(instance, mailbox)
+        run!
+      end
+
+      def method_missing(method, *args, &block)
+        mailbox << CapistranoSentinel::AsyncActor::Context.new(method, args, block)
+        nil
+      end
+    end
+
+      private
+
+      def run!
+        Thread.new do
+          loop do
+            break if mailbox.empty?
+            begin
+              mailbox.synchronize do
+                ctx = mailbox.pop
+                instance.public_send(ctx.method, *ctx.args, &ctx.block)
+              end
+            rescue => e
+              log_to_file("crashed with #{e.inspect} #{e.backtrace}")
+            end
+          end
+        end
+      end
+
+      def async_queue
+        @async_queue ||= Queue.new.extend(MonitorMixin)
+      end
+
+      def async
+        @async ||= CapistranoSentinel::AsyncActor::Async.new(self, async_queue)
+      end
+    end
+  end

data/lib/capistrano_sentinel/helpers/application_helper.rb

@@ -0,0 +1,47 @@
+require_relative './logging'
+module CapistranoSentinel
+  # class that holds the options that are configurable for this gem
+  module ApplicationHelper
+    include CapistranoSentinel::Logging
+    module_function
+
+    # Method that is used to parse a string as JSON , if it fails will return nil
+    # @see JSON#parse
+    # @param [string] res The string that will be parsed as JSON
+    # @return [Hash, nil] Returns Hash object if the json parse succeeds or nil otherwise
+    def parse_json(res)
+      return if res.blank?
+      JSON.parse(res)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def show_warning(message)
+      warn message
+    end
+
+
+    def msg_for_stdin?(message)
+      message['action'] == 'stdin'
+    end
+
+    def message_is_for_stdout?(message)
+      message.present? && message.is_a?(Hash) && message['action'].present? && message['job_id'].present? && message['action'] == 'stdout'
+    end
+
+    def message_is_about_a_task?(message)
+      message.present? && message.is_a?(Hash) && message['action'].present? && message['job_id'].present? && message['task'].present? && message['action'] == 'invoke'
+    end
+
+    def message_from_bundler?(message)
+      message.present? && message.is_a?(Hash) && message['action'].present? && message['job_id'].present? && message['task'].present? && message['action'] == 'bundle_install'
+    end
+
+    def get_question_details(data)
+      matches = /(.*)\?*\s*\:*\s*(\([^)]*\))*/m.match(data).captures
+      [matches[0], matches[1]]
+    end
+
+
+  end
+end

data/lib/capistrano_sentinel/helpers/logging.rb

@@ -0,0 +1,79 @@
+module CapistranoSentinel
+  # class that holds the options that are configurable for this gem
+  module Logging
+    module_function
+
+    def logger
+      @logger ||= ::Logger.new('/home/raul/workspace/ecommerce/ecommerce-livechat/log/multi_cap.log')
+    end
+
+    def error_filtered?(error)
+      [SystemExit].find { |class_name| error.is_a?(class_name) }.present?
+    end
+
+    def log_error(error, options = {})
+      message = format_error(error)
+      log_output_error(error, options.fetch(:output, nil), message)
+      log_to_file(message, options.merge(log_method: 'fatal'))
+    end
+
+    def log_output_error(error, output, message)
+      return if message.blank? || error_filtered?(error)
+      puts message if output.present?
+      terminal_actor.errors.push(message) if terminal_errors?
+    end
+
+    def format_error(exception)
+      message = "\n#{exception.class} (#{exception.respond_to?(:message) ? exception.message : exception.inspect}):\n"
+      message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
+      message << '  ' << exception.backtrace.join("\n  ") if exception.respond_to?(:backtrace)
+      message
+    end
+
+    def log_to_file(message, options = {})
+      worker_log = options.fetch(:job_id, '').present? ? find_worker_log(options[:job_id]) : logger
+      print_to_log_file(worker_log, options.merge(message: message)) if worker_log.present?
+    end
+
+    def print_to_log_file(worker_log, options = {})
+      worker_log.send(options.fetch(:log_method, 'debug'), "#{options.fetch(:message, '')}\n")
+    end
+
+    def find_worker_log(job_id)
+      return if job_id.blank?
+      FileUtils.mkdir_p(log_directory) unless File.directory?(log_directory)
+      filename = File.join(log_directory, "worker_#{job_id}.log")
+      setup_filename_logger(filename)
+    end
+
+    def setup_filename_logger(filename)
+      worker_log = ::Logger.new(filename)
+      worker_log.level = ::Logger::Severity::DEBUG
+      setup_logger_formatter(worker_log)
+      worker_log
+    end
+
+    def setup_logger_formatter(logger)
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        date_format = datetime.strftime('%Y-%m-%d %H:%M:%S')
+        "[#{date_format}] #{severity}  (#{progname}): #{msg}\n"
+      end
+    end
+
+    def execute_with_rescue(output = nil)
+      yield if block_given?
+    rescue Interrupt
+      rescue_interrupt
+    rescue => error
+      rescue_error(error, output)
+    end
+
+    def rescue_error(error, output = nil)
+      log_error(error, output: output)
+      exit(1)
+    end
+
+
+
+end
+end

data/lib/capistrano_sentinel/initializers/active_support/blank.rb

@@ -0,0 +1,143 @@
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies
+  #
+  #   !address || address.empty?
+  #
+  # to
+  #
+  #   address.blank?
+  #
+  # @return [true, false]
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  #
+  # @return [true, false]
+  def present?
+    !blank?
+  end
+
+  # Returns the receiver if it's present otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to
+  #
+  #    object.present? ? object : nil
+  #
+  # For example, something like
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # becomes
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  #
+  # @return [Object]
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class String
+  BLANK_RE2 = /\A[[:space:]]*\z/
+
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?       # => true
+  #   '   '.blank?    # => true
+  #   "\t\n\r".blank? # => true
+  #   ' blah '.blank? # => false
+  #
+  # Unicode whitespace is supported:
+  #
+  #   "\u00a0".blank? # => true
+  #
+  # @return [true, false]
+  def blank?
+    # The regexp that matches blank strings is expensive. For the case of empty
+    # strings we can speed up this method (~3.5x) with an empty? call. The
+    # penalty for the rest of strings is marginal.
+    empty? || BLANK_RE2 === self
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Time #:nodoc:
+  # No Time is blank:
+  #
+  #   Time.now.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end

data/lib/capistrano_sentinel/initializers/active_support/hash_keys.rb

@@ -0,0 +1,172 @@
+class Hash
+
+  # Returns a new hash with all keys converted using the +block+ operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
+  #
+  # If you do not provide a +block+, it will return an Enumerator
+  # for chaining with other methods:
+  #
+  #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) { size } unless block_given?
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively converts all keys using the +block+ operations.
+  # Same as +transform_keys+ but modifies +self+.
+  def transform_keys!
+    return enum_for(:transform_keys!) { size } unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys(&:to_s)
+  end
+
+  # Destructively converts all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options,  :symbolize_keys
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validates all keys in a hash match <tt>*valid_keys</tt>, raising
+  # +ArgumentError+ on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      unless valid_keys.include?(k)
+        raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+      end
+    end
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively converts all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys(&:to_s)
+  end
+
+  # Destructively converts all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys!
+    deep_transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+
+  private
+    # support methods for deep transforming nested hashes and arrays
+    def _deep_transform_keys_in_object(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map {|e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+      end
+    end
+
+    def _deep_transform_keys_in_object!(object, &block)
+      case object
+      when Hash
+        object.keys.each do |key|
+          value = object.delete(key)
+          object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+        end
+        object
+      when Array
+        object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+      else
+        object
+      end
+    end
+
+end