leap_cli 1.8.1 → 1.9

data/lib/leap_cli/config/object_list.rb

@@ -1,209 +0,0 @@
-require 'tsort'
-
-module LeapCli
-  module Config
-    #
-    # A list of Config::Object instances (internally stored as a hash)
-    #
-    class ObjectList < Hash
-      include TSort
-
-      def initialize(config=nil)
-        if config
-          self.add(config['name'], config)
-        end
-      end
-
-      #
-      # If the key is a string, the Config::Object it references is returned.
-      #
-      # If the key is a hash, we treat it as a condition and filter all the Config::Objects using the condition.
-      # A new ObjectList is returned.
-      #
-      # Examples:
-      #
-      # nodes['vpn1']
-      #   node named 'vpn1'
-      #
-      # nodes[:public_dns => true]
-      #   all nodes with public dns
-      #
-      # nodes[:services => 'openvpn', 'location.country_code' => 'US']
-      #   all nodes with services containing 'openvpn' OR country code of US
-      #
-      # Sometimes, you want to do an OR condition with multiple conditions
-      # for the same field. Since hash keys must be unique, you can use
-      # an array representation instead:
-      #
-      # nodes[[:services, 'openvpn'], [:services, 'tor']]
-      #   nodes with openvpn OR tor service
-      #
-      # nodes[:services => 'openvpn'][:tags => 'production']
-      #   nodes with openvpn AND are production
-      #
-      def [](key)
-        if key.is_a?(Hash) || key.is_a?(Array)
-          filter(key)
-        else
-          super key.to_s
-        end
-      end
-
-      def exclude(node)
-        list = self.dup
-        list.delete(node.name)
-        return list
-      end
-
-      def each_node(&block)
-        self.keys.sort.each do |node_name|
-          yield self[node_name]
-        end
-      end
-
-      #
-      # filters this object list, producing a new list.
-      # filter is an array or a hash. see []
-      #
-      def filter(filter)
-        results = Config::ObjectList.new
-        filter.each do |field, match_value|
-          field = field.is_a?(Symbol) ? field.to_s : field
-          match_value = match_value.is_a?(Symbol) ? match_value.to_s : match_value
-          if match_value.is_a?(String) && match_value =~ /^!/
-            operator = :not_equal
-            match_value = match_value.sub(/^!/, '')
-          else
-            operator = :equal
-          end
-          each do |name, config|
-            value = config[field]
-            if value.is_a? Array
-              if operator == :equal && value.include?(match_value)
-                results[name] = config
-              elsif operator == :not_equal && !value.include?(match_value)
-                results[name] = config
-              end
-            else
-              if operator == :equal && value == match_value
-                results[name] = config
-              elsif operator == :not_equal && value != match_value
-                results[name] = config
-              end
-            end
-          end
-        end
-        results
-      end
-
-      def add(name, object)
-        self[name] = object
-      end
-
-      #
-      # converts the hash of configs into an array of hashes, with ONLY the specified fields
-      #
-      def fields(*fields)
-        result = []
-        keys.sort.each do |name|
-          result << self[name].pick(*fields)
-        end
-        result
-      end
-
-      #
-      # like fields(), but returns an array of values instead of an array of hashes.
-      #
-      def field(field)
-        field = field.to_s
-        result = []
-        keys.sort.each do |name|
-          result << self[name].get(field)
-        end
-        result
-      end
-
-      #
-      # pick_fields(field1, field2, ...)
-      #
-      # generates a Hash from the object list, but with only the fields that are picked.
-      #
-      # If there are more than one field, then the result is a Hash of Hashes.
-      # If there is just one field, it is a simple map to the value.
-      #
-      # For example:
-      #
-      #   "neighbors" = "= nodes_like_me[:services => :couchdb].pick_fields('domain.full', 'ip_address')"
-      #
-      # generates this:
-      #
-      #   neighbors:
-      #     couch1:
-      #       domain_full: couch1.bitmask.net
-      #       ip_address: "10.5.5.44"
-      #     couch2:
-      #       domain_full: couch2.bitmask.net
-      #       ip_address: "10.5.5.52"
-      #
-      # But this:
-      #
-      #   "neighbors": "= nodes_like_me[:services => :couchdb].pick_fields('domain.full')"
-      #
-      # will generate this:
-      #
-      #   neighbors:
-      #     couch1: couch1.bitmask.net
-      #     couch2: couch2.bitmask.net
-      #
-      def pick_fields(*fields)
-        self.values.inject({}) do |hsh, node|
-          value = self[node.name].pick(*fields)
-          if fields.size == 1
-            value = value.values.first
-          end
-          hsh[node.name] = value
-          hsh
-        end
-      end
-
-      #
-      # Applies inherit_from! to all objects.
-      #
-      # 'env' specifies what environment should be for
-      # each object in the list.
-      #
-      def inherit_from!(object_list, env)
-        object_list.each do |name, object|
-          if self[name]
-            self[name].inherit_from!(object)
-          else
-            self[name] = object.duplicate(env)
-          end
-        end
-      end
-
-      #
-      # topographical sort based on test dependency
-      #
-      def tsort_each_node(&block)
-        self.each_key(&block)
-      end
-
-      def tsort_each_child(node_name, &block)
-        if self[node_name]
-          self[node_name].test_dependencies.each do |test_me_first|
-            if self[test_me_first] # TODO: in the future, allow for ability to optionally pull in all dependencies.
-                                   # not just the ones that pass the node filter.
-              yield(test_me_first)
-            end
-          end
-        end
-      end
-
-      def names_in_test_dependency_order
-        self.tsort
-      end
-
-    end
-  end
-end

data/lib/leap_cli/config/provider.rb

@@ -1,22 +0,0 @@
-#
-# Configuration class for provider.json
-#
-
-module LeapCli; module Config
-  class Provider < Object
-    attr_reader :environment
-    def set_env(e)
-      if e == 'default'
-        @environment = nil
-      else
-        @environment = e
-      end
-    end
-    def provider
-      self
-    end
-    def validate!
-      # nothing here yet :(
-    end
-  end
-end; end

data/lib/leap_cli/config/secrets.rb

@@ -1,87 +0,0 @@
-# encoding: utf-8
-#
-# A class for the secrets.json file
-#
-
-module LeapCli; module Config
-
-  class Secrets < Object
-    attr_reader :node_list
-
-    def initialize(manager=nil)
-      super(manager)
-      @discovered_keys = {}
-    end
-
-    # we can't use fetch() or get(), since those already have special meanings
-    def retrieve(key, environment)
-      environment ||= 'default'
-      self.fetch(environment, {})[key.to_s]
-    end
-
-    def set(*args, &block)
-      if block_given?
-        set_with_block(*args, &block)
-      else
-        set_without_block(*args)
-      end
-    end
-
-    # searches over all keys matching the regexp, checking to see if the value
-    # has been already used by any of them.
-    def taken?(regexp, value, environment)
-      self.keys.grep(regexp).each do |key|
-        return true if self.retrieve(key, environment) == value
-      end
-      return false
-    end
-
-    def set_without_block(key, value, environment)
-      set_with_block(key, environment) {value}
-    end
-
-    def set_with_block(key, environment, &block)
-      environment ||= 'default'
-      key = key.to_s
-      @discovered_keys[environment] ||= {}
-      @discovered_keys[environment][key] = true
-      self[environment] ||= {}
-      self[environment][key] ||= yield
-    end
-
-    #
-    # if clean is true, then only secrets that have been discovered
-    # during this run will be exported.
-    #
-    # if environment is also pinned, then we will clean those secrets
-    # just for that environment.
-    #
-    # the clean argument should only be used when all nodes have
-    # been processed, otherwise secrets that are actually in use will
-    # get mistakenly removed.
-    #
-    def dump_json(clean=false)
-      pinned_env = LeapCli.leapfile.environment
-      if clean
-        self.each_key do |environment|
-          if pinned_env.nil? || pinned_env == environment
-            env = self[environment]
-            if env.nil?
-              raise StandardError.new("secrets.json file seems corrupted. No such environment '#{environment}'")
-            end
-            env.each_key do |key|
-              unless @discovered_keys[environment] && @discovered_keys[environment][key]
-                self[environment].delete(key)
-              end
-            end
-            if self[environment].empty?
-              self.delete(environment)
-            end
-          end
-        end
-      end
-      super()
-    end
-  end
-
-end; end

data/lib/leap_cli/config/sources.rb

@@ -1,11 +0,0 @@
-# encoding: utf-8
-#
-# A class for the sources.json file
-#
-
-module LeapCli
-  module Config
-    class Sources < Object
-    end
-  end
-end

data/lib/leap_cli/config/tag.rb

@@ -1,25 +0,0 @@
-#
-#
-# A class for node services or node tags.
-#
-#
-
-module LeapCli; module Config
-
-  class Tag < Object
-    attr_reader :node_list
-
-    def initialize(environment=nil)
-      super(environment)
-      @node_list = Config::ObjectList.new
-    end
-
-    # don't copy the node list pointer when this object is dup'ed.
-    def initialize_copy(orig)
-      super
-      @node_list = Config::ObjectList.new
-    end
-
-  end
-
-end; end

data/lib/leap_cli/lib_ext/capistrano_connections.rb

@@ -1,16 +0,0 @@
-module Capistrano
-  class Configuration
-    module Connections
-      def failed!(server)
-        @failure_callback.call(server) if @failure_callback
-        Thread.current[:failed_sessions] << server
-      end
-
-      def call_on_failure(&block)
-        @failure_callback = block
-      end
-    end
-  end
-end
-
-

data/lib/leap_cli/logger.rb

@@ -1,237 +0,0 @@
-#
-# A drop in replacement for Capistrano::Logger that integrates better with LEAP CLI.
-#
-
-require 'capistrano/logger'
-
-#
-# from Capistrano::Logger
-# =========================
-#
-# IMPORTANT = 0
-# INFO      = 1
-# DEBUG     = 2
-# TRACE     = 3
-# MAX_LEVEL = 3
-# COLORS = {
-#   :none     => "0",
-#   :black    => "30",
-#   :red      => "31",
-#   :green    => "32",
-#   :yellow   => "33",
-#   :blue     => "34",
-#   :magenta  => "35",
-#   :cyan     => "36",
-#   :white    => "37"
-# }
-# STYLES = {
-#   :bright     => 1,
-#   :dim        => 2,
-#   :underscore => 4,
-#   :blink      => 5,
-#   :reverse    => 7,
-#   :hidden     => 8
-# }
-#
-
-module LeapCli
-  class Logger < Capistrano::Logger
-
-    def initialize(options={})
-      @options = options
-      @level = options[:level] || 0
-      @message_buffer = nil
-    end
-
-    def log(level, message, line_prefix=nil, options={})
-      if message !~ /\n$/ && level <= 2 && line_prefix.is_a?(String)
-        # in some cases, when the message doesn't end with a return, we buffer it and
-        # wait until we encounter the return before we log the message out.
-        @message_buffer ||= ""
-        @message_buffer += message
-        return
-      elsif @message_buffer
-        message = @message_buffer + message
-        @message_buffer = nil
-      end
-
-      options[:level] ||= level
-      [:stdout, :log].each do |mode|
-        LeapCli::log_raw(mode) do
-          message_lines(mode, message, line_prefix, options)
-        end
-      end
-    end
-
-    private
-
-    def message_lines(mode, message, line_prefix, options)
-      formatted_message, formatted_prefix, message_options = apply_formatting(mode, message, line_prefix, options)
-      if message_options[:level] <= self.level && formatted_message && formatted_message.chars.any?
-        if formatted_prefix
-          formatted_message.lines.collect { |line|
-            "[#{formatted_prefix}] #{line.sub(/\s+$/, '')}"
-          }
-        else
-          formatted_message.lines.collect {|line| line.sub(/\s+$/, '')}
-        end
-      else
-        nil
-      end
-    end
-
-    ##
-    ## FORMATTING
-    ##
-
-    #
-    # options for formatters:
-    #
-    # :match       =>  regexp for matching a log line
-    # :color       => what color the line should be
-    # :style       => what style the line should be
-    # :priority    => what order the formatters are applied in. higher numbers first.
-    # :match_level => only apply filter at the specified log level
-    # :level       => make this line visible at this log level or higher
-    # :replace     => replace the matched text
-    # :exit        => force the exit code to be this (does not interrupt program, just
-    #                 ensures a specific exit code when the program eventually exits)
-    #
-    @formatters = [
-      # TRACE
-      { :match => /command finished/,          :color => :white,   :style => :dim, :match_level => 3, :priority => -10 },
-      { :match => /executing locally/,         :color => :yellow,  :match_level => 3, :priority => -20 },
-
-      # DEBUG
-      #{ :match => /executing .*/,             :color => :green,   :match_level => 2, :priority => -10, :timestamp => true },
-      #{ :match => /.*/,                        :color => :yellow,  :match_level => 2, :priority => -30 },
-      { :match => /^transaction:/,             :level => 3 },
-
-      # INFO
-      { :match => /.*out\] (fatal:|ERROR:).*/, :color => :red,     :match_level => 1, :priority => -10 },
-      { :match => /Permission denied/,         :color => :red,     :match_level => 1, :priority => -20 },
-      { :match => /sh: .+: command not found/, :color => :magenta, :match_level => 1, :priority => -30 },
-
-      # IMPORTANT
-      { :match => /^(E|e)rr ::/,                   :color => :red,     :match_level => 0, :priority => -10, :exit => 1},
-      { :match => /^ERROR:/,                   :color => :red,                        :priority => -10, :exit => 1},
-      { :match => /.*/,                        :color => :blue,    :match_level => 0, :priority => -20 },
-
-      # CLEANUP
-      { :match => /\s+$/,                      :replace => '', :priority => 0},
-
-      # DEBIAN PACKAGES
-      { :match => /^(Hit|Ign) /,                :color => :green,   :priority => -20},
-      { :match => /^Err /,                      :color => :red,     :priority => -20},
-      { :match => /^W(ARNING)?: /,              :color => :yellow,  :priority => -20},
-      { :match => /^E: /,                       :color => :red,     :priority => -20},
-      { :match => /already the newest version/, :color => :green,   :priority => -20},
-      { :match => /WARNING: The following packages cannot be authenticated!/, :color => :red, :level => 0, :priority => -10},
-
-      # PUPPET
-      { :match => /^(W|w)arning: Not collecting exported resources without storeconfigs/, :level => 2, :color => :yellow, :priority => -10},
-      { :match => /^(W|w)arning: Found multiple default providers for vcsrepo:/,          :level => 2, :color => :yellow, :priority => -10},
-      { :match => /^(W|w)arning: .*is deprecated.*$/, :level => 2, :color => :yellow, :priority => -10},
-      { :match => /^(W|w)arning: Scope.*$/,           :level => 2, :color => :yellow, :priority => -10},
-      { :match => /^(N|n)otice:/,                     :level => 1, :color => :cyan,   :priority => -20},
-      { :match => /^(N|n)otice:.*executed successfully$/, :level => 2, :color => :cyan, :priority => -15},
-      { :match => /^(W|w)arning:/,                    :level => 0, :color => :yellow, :priority => -20},
-      { :match => /^Duplicate declaration:/,          :level => 0, :color => :red,    :priority => -20},
-      { :match => /Finished catalog run/,             :level => 0, :color => :green,  :priority => -10},
-      { :match => /^APPLY COMPLETE \(changes made\)/, :level => 0, :color => :green,  :priority => -10},
-      { :match => /^APPLY COMPLETE \(no changes\)/,   :level => 0, :color => :green,  :priority => -10},
-
-      # PUPPET FATAL ERRORS
-      { :match => /^(E|e)rr(or|):/,                :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^Wrapped exception:/,           :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^Failed to parse template/,     :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^Execution of.*returned/,     :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^Parameter matches failed:/,    :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^Syntax error/,                 :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^Cannot reassign variable/,     :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^Could not find template/,      :level => 0, :color => :red, :priority => -1, :exit => 1},
-      { :match => /^APPLY COMPLETE.*fail/,         :level => 0, :color => :red, :priority => -1, :exit => 1},
-
-      # TESTS
-      { :match => /^PASS: /,                :color => :green,   :priority => -20},
-      { :match => /^(FAIL|ERROR): /,        :color => :red,     :priority => -20},
-      { :match => /^(SKIP|WARN): /,         :color => :yellow,  :priority => -20},
-      { :match => /\d+ tests: \d+ passes, \d+ skips, 0 warnings, 0 failures, 0 errors/, :color => :blue, :priority => -20},
-
-      # LOG SUPPRESSION
-      { :match => /^(W|w)arning: You cannot collect without storeconfigs being set/, :level => 2, :priority => 10},
-      { :match => /^(W|w)arning: You cannot collect exported resources without storeconfigs being set/, :level => 2, :priority => 10}
-    ]
-
-    def self.sorted_formatters
-      # Sort matchers in reverse order so we can break if we found a match.
-      @sorted_formatters ||= @formatters.sort_by { |i| -(i[:priority] || i[:prio] || 0) }
-    end
-
-    @prefix_formatters = [
-      { :match => /(err|out) :: /,             :replace => '', :priority => 0},
-      { :match => /\s+$/,                      :replace => '', :priority => 0}
-    ]
-    def self.prefix_formatters; @prefix_formatters; end
-
-    def apply_formatting(mode, message, line_prefix = nil, options={})
-      message = message.dup
-      options = options.dup
-      if !line_prefix.nil?
-        if !line_prefix.is_a?(String)
-          line_prefix = line_prefix.to_s.dup
-        else
-          line_prefix = line_prefix.dup
-        end
-      end
-      color = options[:color] || :none
-      style = options[:style]
-
-      if line_prefix
-        self.class.prefix_formatters.each do |formatter|
-          if line_prefix =~ formatter[:match] && formatter[:replace]
-            line_prefix.gsub!(formatter[:match], formatter[:replace])
-          end
-        end
-      end
-
-      self.class.sorted_formatters.each do |formatter|
-        if (formatter[:match_level] == level || formatter[:match_level].nil?)
-          if message =~ formatter[:match]
-            options[:level] = formatter[:level] if formatter[:level]
-            color = formatter[:color] if formatter[:color]
-            style = formatter[:style] || formatter[:attribute] # (support original cap colors)
-
-            message.gsub!(formatter[:match], formatter[:replace]) if formatter[:replace]
-            message.replace(formatter[:prepend] + message) unless formatter[:prepend].nil?
-            message.replace(message + formatter[:append])  unless formatter[:append].nil?
-            message.replace(Time.now.strftime('%Y-%m-%d %T') + ' ' + message) if formatter[:timestamp]
-
-            if formatter[:exit]
-              LeapCli::Util.exit_status(formatter[:exit])
-            end
-
-            # stop formatting, unless formatter was just for string replacement
-            break unless formatter[:replace]
-          end
-        end
-      end
-
-      if color == :hide
-        return nil
-      elsif mode == :log || (color == :none && style.nil?) || !LeapCli.log_in_color
-        return [message, line_prefix, options]
-      else
-        term_color = COLORS[color]
-        term_style = STYLES[style]
-        if line_prefix.nil?
-          message.replace format(message, term_color, term_style)
-        else
-          line_prefix.replace format(line_prefix, term_color, term_style).strip # format() appends a \n
-        end
-        return [message, line_prefix, options]
-      end
-    end
-
-  end
-end