leap_cli 1.8.1 → 1.9

data/lib/leap_cli/core_ext/hash.rb

@@ -32,4 +32,23 @@ class Hash
     replace(deep_merge(other_hash))
   end
 
+  #
+  # A recursive symbolize_keys
+  #
+  unless Hash.method_defined?(:symbolize_keys)
+    def symbolize_keys
+      self.inject({}) {|result, (key, value)|
+        new_key = case key
+                  when String then key.to_sym
+                  else key
+                  end
+        new_value = case value
+                    when Hash then symbolize_keys(value)
+                    else value
+                    end
+        result[new_key] = new_value
+        result
+      }
+    end
+  end
 end

data/lib/leap_cli/leapfile.rb

@@ -3,6 +3,8 @@
 #
 # It is akin to a Gemfile, Rakefile, or Capfile (e.g. it is a ruby file that gets eval'ed)
 #
+# Additional configuration options are defined in platform's leapfile_extensions.rb
+#
 
 module LeapCli
   def self.leapfile
@@ -10,17 +12,12 @@ module LeapCli
   end
 
   class Leapfile
-    attr_accessor :platform_directory_path
-    attr_accessor :provider_directory_path
-    attr_accessor :custom_vagrant_vm_line
-    attr_accessor :leap_version
-    attr_accessor :log
-    attr_accessor :vagrant_network
-    attr_accessor :vagrant_basebox
-    attr_accessor :environment
+    attr_reader :platform_directory_path
+    attr_reader :provider_directory_path
+    attr_reader :environment
+    attr_reader :valid
 
     def initialize
-      @vagrant_network = '10.5.5.0/24'
     end
 
     #
@@ -61,25 +58,44 @@ module LeapCli
         #
         # load the platform
         #
-        platform_file = "#{@platform_directory_path}/platform.rb"
-        unless File.exists?(platform_file)
+        platform_class = "#{@platform_directory_path}/lib/leap/platform"
+        platform_definition = "#{@platform_directory_path}/platform.rb"
+        unless File.exist?(platform_definition)
           Util.bail! "ERROR: The file `#{platform_file}` does not exist. Please check the value of `@platform_directory_path` in `Leapfile` or `~/.leaprc`."
         end
-        require "#{@platform_directory_path}/platform.rb"
-        if !Leap::Platform.compatible_with_cli?(LeapCli::VERSION) ||
-           !Leap::Platform.version_in_range?(LeapCli::COMPATIBLE_PLATFORM_VERSION)
-          Util.bail! "This leap command (v#{LeapCli::VERSION}) " +
-                     "is not compatible with the platform #{@platform_directory_path} (v#{Leap::Platform.version}).\n   " +
-                     "You need either leap command #{Leap::Platform.compatible_cli.first} to #{Leap::Platform.compatible_cli.last} or " +
-                     "platform version #{LeapCli::COMPATIBLE_PLATFORM_VERSION.first} to #{LeapCli::COMPATIBLE_PLATFORM_VERSION.last}"
+        begin
+          require platform_class
+          require platform_definition
+        rescue LoadError
+          Util.log "The leap_platform at #{platform_directory_path} is not compatible with this version of leap_cli"
+          Util.log "You can either:" do
+            Util.log "Upgrade leap_platform to version " + LeapCli::COMPATIBLE_PLATFORM_VERSION.first
+            Util.log "Or, downgrade leap_cli to version 1.8"
+          end
+          Util.bail!
+        rescue StandardError => exc
+          Util.bail! exc.to_s
         end
-        unless @allow_production_deploy.nil?
-          Util::log 0, :warning, "in Leapfile: @allow_production_deploy is no longer supported."
+        begin
+          Leap::Platform.validate!(LeapCli::VERSION, LeapCli::COMPATIBLE_PLATFORM_VERSION, self)
+        rescue StandardError => exc
+          Util.bail! exc.to_s
         end
-        unless @platform_branch.nil?
-          Util::log 0, :warning, "in Leapfile: @platform_branch is no longer supported."
+        leapfile_extensions = "#{@platform_directory_path}/lib/leap_cli/leapfile_extensions.rb"
+        if File.exist?(leapfile_extensions)
+          require leapfile_extensions
         end
-        @valid = true
+
+        #
+        # validate
+        #
+        instance_variables.each do |var|
+          var = var.to_s.sub('@', '')
+          if !self.respond_to?(var)
+            LeapCli.log :warning, "the variable `#{var}` is set in .leaprc or Leapfile, but it is not supported."
+          end
+        end
+        @valid = validate
         return @valid
       end
     end
@@ -105,7 +121,7 @@ module LeapCli
     def edit_leaprc(property, value=nil)
       file_path = leaprc_path
       lines = []
-      if File.exists?(file_path)
+      if File.exist?(file_path)
         regexp = /self\.#{Regexp.escape(property)} = .*? if @provider_directory_path == '#{Regexp.escape(@provider_directory_path)}'/
         File.readlines(file_path).each do |line|
           unless line =~ regexp
@@ -128,10 +144,9 @@ module LeapCli
     end
 
     def read_settings(file)
-      if File.exists? file
-        Util::log 2, :read, file
+      if File.exist? file
+        LeapCli.log 2, :read, file
         instance_eval(File.read(file), file)
-        validate(file)
       end
     end
 
@@ -146,11 +161,11 @@ module LeapCli
       return search_dir
     end
 
-    PRIVATE_IP_RANGES = /(^127\.0\.0\.1)|(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^192\.168\.)/
-
-    def validate(file)
-      Util::assert! vagrant_network =~ PRIVATE_IP_RANGES do
-        Util::log 0, :error, "in #{file}: vagrant_network is not a local private network"
+    def method_missing(method, *args)
+      if method =~ /=$/
+        self.instance_variable_set('@' + method.to_s.sub('=',''), args.first)
+      else
+        self.instance_variable_get('@' + method.to_s)
       end
     end
 

data/lib/leap_cli/log.rb

@@ -1,58 +1,84 @@
-require 'paint'
-
 ##
 ## LOGGING
 ##
-## Ugh. This class does not work well with multiple threads!
-##
 
 module LeapCli
-  extend self
+  module LogCommand
+    @@logger = nil
 
-  attr_accessor :log_in_color
+    def log(*args, &block)
+      logger.log(*args, &block)
+    end
 
-  # logging options
-  def log_level
-    @log_level ||= 1
-  end
-  def set_log_level(value)
-    @log_level = value
-  end
+    def log_raw(*args, &block)
+      logger.log_raw(*args, &block)
+    end
 
-  def indent_level
-    @indent_level ||= 0
-  end
-  def indent_level=(value)
-    @indent_level = value
-  end
+    # global shared logger
+    def logger
+      @@logger ||= LeapCli::LeapLogger.new
+    end
 
-  def log_file
-    @log_file
-  end
-  def log_file=(value)
-    @log_file = value
-    if @log_file
-      if !File.directory?(File.dirname(@log_file))
-        Util.bail!('Invalid log file "%s", directory "%s" does not exist' % [@log_file, File.dirname(@log_file)])
-      end
-      @log_output_stream = File.open(@log_file, 'a')
+    # thread safe logger
+    def new_logger
+      logger.dup
     end
-  end
 
-  def log_output_stream
-    @log_output_stream
-  end
+    # deprecated
+    def log_level
+      logger.log_level
+    end
+
+    #
+    # These probably should have been part of the logger originally,
+    # but they are made available here for convenience:
+    #
+
+    def bail!(*args, &block)
+      Util.bail!(*args, &block)
+    end
 
+    def assert!(*args, &block)
+      Util.assert!(*args, &block)
+    end
+
+  end
 end
 
 
 module LeapCli
-  module Log
+  class LeapLogger
     #
     # these are log titles typically associated with files
     #
-    FILE_TITLES = [:updated, :created, :removed, :missing, :nochange, :loading]
+    FILE_TITLES = %w(updated created removed missing nochange loading)
+
+    # TODO: use these
+    IMPORTANT = 0
+    INFO      = 1
+    DEBUG     = 2
+    TRACE     = 3
 
+    attr_reader :log_output_stream, :log_file
+    attr_accessor :indent_level, :log_level, :log_in_color
+
+    def initialize()
+      @log_level = 1
+      @indent_level = 0
+      @log_file = nil
+      @log_output_stream = nil
+      @log_in_color = true
+    end
+
+    def log_file=(value)
+      @log_file = value
+      if @log_file
+        if !File.directory?(File.dirname(@log_file))
+          Util.bail!('Invalid log file "%s", directory "%s" does not exist' % [@log_file, File.dirname(@log_file)])
+        end
+        @log_output_stream = File.open(@log_file, 'a')
+      end
+    end
 
     #
     # master logging function.
@@ -63,74 +89,95 @@ module LeapCli
     # * Integer: the log level (0, 1, 2)
     # * Symbol: the prefix title to colorize. may be one of
     #   [:error, :warning, :info, :updated, :created, :removed, :no_change, :missing]
-    # * Hash: a hash of options. so far, only :indent is supported.
+    # * Hash: a hash of options.
+    #     :wrap -- if true, appy intend to each line in message.
+    #     :color -- apply color to message or prefix
+    #     :style -- apply style to message or prefix
     #
-
     def log(*args)
       level   = args.grep(Integer).first || 1
       title   = args.grep(Symbol).first
       message = args.grep(String).first
       options = args.grep(Hash).first || {}
-      unless message && LeapCli.log_level >= level
+      host    = options[:host]
+      if title
+        title = title.to_s
+      end
+      if @log_level < level || (title.nil? && message.nil?)
         return
       end
 
-      # prefix
-      clear_prefix = colored_prefix = ""
-      if title
-        prefix_options = case title
-          when :error     then ['error', :red, :bold]
-          when :fatal_error then ['fatal error:', :red, :bold]
-          when :warning   then ['warning:', :yellow, :bold]
-          when :info      then ['info', :cyan, :bold]
-          when :note      then ['NOTE:', :cyan, :bold]
-          when :updated   then ['updated', :cyan, :bold]
-          when :updating  then ['updating', :cyan, :bold]
-          when :created   then ['created', :green, :bold]
-          when :removed   then ['removed', :red, :bold]
-          when :nochange  then ['no change', :magenta]
-          when :loading   then ['loading', :magenta]
-          when :missing   then ['missing', :yellow, :bold]
-          when :skipping  then ['skipping', :yellow, :bold]
-          when :run       then ['run', :magenta]
-          when :failed    then ['FAILED', :red, :bold]
-          when :completed then ['completed', :green, :bold]
-          when :ran       then ['ran', :green, :bold]
-          when :bail      then ['bailing out', :red, :bold]
-          when :invalid   then ['invalid', :red, :bold]
-          else [title.to_s, :cyan, :bold]
-        end
-        if options[:host]
-          clear_prefix = "[%s] %s " % [options[:host], prefix_options[0]]
-          colored_prefix = "[%s] %s " % [Paint[options[:host], prefix_options[1], prefix_options[2]], prefix_options[0]]
+      #
+      # transform absolute path names
+      #
+      if title && FILE_TITLES.include?(title) && message =~ /^\//
+        message = LeapCli::Path.relative_path(message)
+      end
+
+      #
+      # apply filters
+      # LogFilter will not be defined if no platform was loaded.
+      #
+      if defined?(LeapCli::LogFilter)
+        if title
+          title, filter_flags = LogFilter.apply_title_filters(title)
         else
-          clear_prefix = "%s " % prefix_options[0]
-          colored_prefix = "%s " % Paint[prefix_options[0], prefix_options[1], prefix_options[2]]
+          message, filter_flags = LogFilter.apply_message_filters(message)
+          return if message.nil?
         end
-      elsif options[:host]
-        clear_prefix = colored_prefix =  "[%s] " % options[:host]
+        options = options.merge(filter_flags)
       end
 
-      # transform absolute path names
-      if title && FILE_TITLES.include?(title) && message =~ /^\//
-        message = LeapCli::Path.relative_path(message)
+      #
+      # set line prefix
+      #
+      if (host)
+        host = host.split('.').first
       end
+      prefix = prefix_str(host, title)
 
-      log_raw(:log, nil)                   { [clear_prefix, message].join }
-      if LeapCli.log_in_color
-        log_raw(:stdout, options[:indent]) { [colored_prefix, message].join }
-      else
-        log_raw(:stdout, options[:indent]) { [clear_prefix, message].join }
+      #
+      # write to the log file, always
+      #
+      log_raw(:log, nil, prefix) { message }
+
+      #
+      # log to stdout, maybe in color
+      #
+      if @log_in_color
+        if options[:wrap]
+          message = message.split("\n")
+        end
+        if options[:color]
+          if host
+            host = colorize(host, options[:color], options[:style])
+          elsif title
+            title = colorize(title, options[:color], options[:style])
+          else
+            message = colorize(message, options[:color], options[:style])
+          end
+        elsif title
+          title = colorize(title, :cyan, :bold)
+        end
+        # new colorized prefix:
+        prefix = prefix_str(host, title)
       end
+      log_raw(:stdout, options[:indent], prefix) { message }
 
-      # run block, if given
+      #
+      # run block indented, if given
+      #
       if block_given?
-        LeapCli.indent_level += 1
+        @indent_level += 1
         yield
-        LeapCli.indent_level -= 1
+        @indent_level -= 1
       end
     end
 
+    def debug(*args)
+      self.log(3, *args)
+    end
+
     #
     # Add a raw log entry, without any modifications (other than indent).
     # Content to be logged is yielded by the block.
@@ -139,23 +186,26 @@ module LeapCli
     # if mode == :stdout, output is sent to STDOUT.
     # if mode == :log, output is sent to log file, if present.
     #
-    def log_raw(mode, indent=nil, &block)
-      # NOTE: print message (using 'print' produces better results than 'puts' when multiple threads are logging)
+    def log_raw(mode, indent=nil, prefix=nil, &block)
+      # NOTE: using 'print' produces better results than 'puts'
+      # when multiple threads are logging)
       if mode == :log
-        if LeapCli.log_output_stream
+        if @log_output_stream
           messages = [yield].compact.flatten
           if messages.any?
             timestamp = Time.now.strftime("%b %d %H:%M:%S")
             messages.each do |message|
-              LeapCli.log_output_stream.print("#{timestamp} #{message}\n")
+              message = message.rstrip
+              next if message.empty?
+              @log_output_stream.print("#{timestamp} #{prefix} #{message}\n")
             end
-            LeapCli.log_output_stream.flush
+            @log_output_stream.flush
           end
         end
       elsif mode == :stdout
         messages = [yield].compact.flatten
         if messages.any?
-          indent ||= LeapCli.indent_level
+          indent ||= @indent_level
           indent_str = ""
           indent_str += "  " * indent.to_i
           if indent.to_i > 0
@@ -163,12 +213,70 @@ module LeapCli
           else
             indent_str += ' = '
           end
+          indent_str += prefix if prefix
           messages.each do |message|
+            message = message.rstrip
+            next if message.empty?
             STDOUT.print("#{indent_str}#{message}\n")
           end
         end
       end
     end
 
+    def colorize(str, color, style=nil)
+      codes = [FG_COLORS[color] || FG_COLORS[:default]]
+      if style
+        codes << EFFECTS[style] || EFFECTS[:nothing]
+      end
+      if str.is_a?(String)
+        ["\033[%sm" % codes.join(';'), str, NO_COLOR].join
+      elsif str.is_a?(Array)
+        str.map { |s|
+          ["\033[%sm" % codes.join(';'), s, NO_COLOR].join
+        }
+      end
+    end
+
+    private
+
+    def prefix_str(host, title)
+      prefix = ""
+      prefix += "[" + host + "] " if host
+      prefix += title + " " if title
+      prefix += " " if !prefix.empty? && prefix !~ / $/
+      return prefix
+    end
+
+    EFFECTS = {
+      :reset         => 0,  :nothing         => 0,
+      :bright        => 1,  :bold            => 1,
+      :underline     => 4,
+      :inverse       => 7,  :swap            => 7,
+    }
+    NO_COLOR = "\033[0m"
+    FG_COLORS = {
+      :black   => 30,
+      :red     => 31,
+      :green   => 32,
+      :yellow  => 33,
+      :blue    => 34,
+      :magenta => 35,
+      :cyan    => 36,
+      :white   => 37,
+      :default => 39,
+    }
+    BG_COLORS = {
+      :black   => 40,
+      :red     => 41,
+      :green   => 42,
+      :yellow  => 43,
+      :blue    => 44,
+      :magenta => 45,
+      :cyan    => 46,
+      :white   => 47,
+      :default => 49,
+    }
+
   end
-end
+end
+