cmdb 2.6.2 → 3.0.0rc1

data/lib/cmdb/interface.rb

@@ -3,31 +3,20 @@ require 'json'
 
 module CMDB
   class Interface
-    # Create a new instance of the CMDB interface.
-    # @option settings [String] root name of subkey to consider as root
-    def initialize(settings = {})
-      @root = settings[:root] if settings
-
-      namespaces = {}
-
-      load_file_sources(namespaces)
-      check_overlap(namespaces)
-
-      @sources = []
-      # Load from consul source first if one is available.
-      unless ConsulSource.url.nil?
-        if ConsulSource.prefixes.nil? || ConsulSource.prefixes.empty?
-          @sources << ConsulSource.new('')
-        else
-          ConsulSource.prefixes.each do |prefix|
-            @sources << ConsulSource.new(prefix)
-          end
-        end
-      end
-      # Register valid sources with CMDB
-      namespaces.each do |_, v|
-        @sources << v.first
+    # Create a new instance of the CMDB interface with the specified sources.
+    # @param [Array] sources list of String or URI source locations
+    # @see Source.create for information on how to specify source URLs
+    def initialize(*sources)
+      # ensure no two sources share a prefix
+      prefixes = {}
+      sources.each do |s|
+        next if s.prefix.nil?
+        prefixes[s.prefix] ||= []
+        prefixes[s.prefix] << s
       end
+      check_overlap(prefixes)
+
+      @sources = sources.dup
     end
 
     # Retrieve the value of a CMDB key, searching all sources in the order they were initialized.
@@ -57,6 +46,23 @@ module CMDB
       get(key) || raise(MissingKey.new(key))
     end
 
+    # Set the value of a CMDB key.
+    #
+    # @return [Source,ni] the source that accepted the write, if any
+    # @raise [BadKey] if the key name is malformed
+    def set(key, value)
+      raise BadKey.new(key) unless key =~ VALID_KEY
+
+      @sources.reverse.each do |s|
+        if s.respond_to?(:set)
+          s.set(key, value)
+          return s
+        end
+      end
+
+      nil
+    end
+
     # Enumerate all of the keys in the CMDB.
     #
     # @yield every key/value in the CMDB
@@ -71,6 +77,19 @@ module CMDB
       self
     end
 
+    def search(prefix)
+      prefix = Regexp.new('^' + Regexp.escape(prefix))
+      result = {}
+
+      @sources.each do |s|
+        s.each_pair do |k, v|
+          result[k] = v if k =~ prefix
+        end
+      end
+
+      result
+    end
+
     # Transform the entire CMDB into a flat Hash that can be merged into ENV.
     # Key names are transformed into underscore-separated, uppercase strings;
     # all runs of non-alphanumeric, non-underscore characters are tranformed
@@ -103,42 +122,15 @@ module CMDB
 
     private
 
-    # Scan for CMDB data files and index them by namespace
-    def load_file_sources(namespaces)
-      # Consult standard base directories for data files
-      directories = FileSource.base_directories
-
-      # Also consult working dir in development environments
-      if CMDB.development?
-        local_dir = File.join(Dir.pwd, '.cmdb')
-        directories += [local_dir]
-      end
-
-      directories.each do |dir|
-        (Dir.glob(File.join(dir, '*.js')) + Dir.glob(File.join(dir, '*.json'))).each do |filename|
-          source = FileSource.new(filename, @root)
-          namespaces[source.prefix] ||= []
-          namespaces[source.prefix] << source
-        end
-
-        (Dir.glob(File.join(dir, '*.yml')) + Dir.glob(File.join(dir, '*.yaml'))).each do |filename|
-          source = FileSource.new(filename, @root)
-          namespaces[source.prefix] ||= []
-          namespaces[source.prefix] << source
-        end
-      end
-    end
-
-    # Check for overlapping namespaces and react appropriately. This can happen when a file
-    # of a given name is located in more than one of the key-search directories. We tolerate
-    # this in development mode, but raise an exception otherwise.
-    def check_overlap(namespaces)
-      overlapping = namespaces.select { |_, sources| sources.size > 1 }
-      overlapping.each do |ns, sources|
-        exc = ValueConflict.new(ns, sources)
+    # Check that no two sources share a prefix. Raise an exception if any
+    # overlap is detected.
+    def check_overlap(prefix_sources)
+      overlapping = prefix_sources.select { |_, sources| sources.size > 1 }
+      overlapping.each do |p, sources|
+        exc = ValueConflict.new(p, sources)
 
-        CMDB.log.warn exc.message
-        raise exc unless CMDB.development?
+        CMDB.log.error exc.message
+        raise exc
       end
     end
 

data/lib/cmdb/shell/dsl.rb

@@ -0,0 +1,73 @@
+module CMDB::Shell
+  # Host for CMDB command methods. Every public method of this class is
+  # a CMDB command and its parameters represent the arguments to the
+  # command. If a command is successful, it always updates the `_` attribute
+  # with the output (return value) of the command.
+  class DSL < BasicObject
+    def initialize(shell, out)
+      @shell = shell
+      @cmdb = @shell.cmdb
+      @out = out
+    end
+
+    def ls(path='')
+      prefix = @shell.expand_path(path)
+      @cmdb.search prefix
+    end
+
+    def help
+      @out.info 'Commands:'
+      @out.info '  cd slash/sep/path - append to search prefix'
+      @out.info '  cd /path          - reset prefix'
+      @out.info '  get <key>         - print value of key'
+      @out.info '  ls                - show keys and values'
+      @out.info '  set <key> <value> - print value of key'
+      @out.info '  quit              - exit the shell'
+      @out.info 'Notation:'
+      @out.info '  a.b.c             - (sub)key relative to search prefix'
+      @out.info '  ../b/c            - the b.c subkey relative to parent of search prefix'
+      @out.info 'Shortcuts:'
+      @out.info '  <key>             - for get'
+      @out.info '  <key>=<value>     - for set'
+      @out.info '  cat,rm,unset,...  - as expected'
+    end
+
+    def get(key)
+      key = @shell.expand_path(key)
+
+      @cmdb.get(key)
+    end
+    alias cat get
+
+    def set(key, value)
+      key = @shell.expand_path key
+
+      if @cmdb.set(key, value)
+        @cmdb.get(key)
+      else
+        ::Kernel.raise ::CMDB::BadCommand.new('set', 'No source is capable of accepting writes')
+      end
+    end
+
+    def unset(key)
+      @cmdb.set(key, nil)
+    end
+    alias rm unset
+
+    def cd(path)
+      pwd = @shell.expand_path(path)
+      @shell.pwd = pwd.split(::CMDB::SEPARATOR)
+      pwd.to_sym
+    end
+    alias chdir cd
+
+    def pry
+
+    end
+
+    def quit
+      ::Kernel.raise ::Interrupt
+    end
+    alias exit quit
+  end
+end

data/lib/cmdb/shell/printer.rb

@@ -0,0 +1,115 @@
+module CMDB::Shell
+  class Printer
+    def initialize(out=STDOUT, err=STDERR)
+      @out = out
+      @err = err
+      @c = Text.new(!@out.tty?)
+    end
+
+    # Print an informational message.
+    def info(str)
+      @out.puts @c.white(str)
+    end
+
+    # Print an error message.
+    def error(str)
+      @err.puts @c.bright_red(str)
+      self
+    end
+
+    # Display a single CMDB value.
+    def value(obj)
+      @out.puts '  ' + color_value(obj, 76)
+      self
+    end
+
+    # Display a table of keys/values.
+    def keys_values(h, prefix:nil)
+      wk = h.keys.inject(0) { |ax, e| e.size > ax ? e.size : ax }
+      wv = h.values.inject(0) { |ax, e| es = e.inspect.size; es > ax ? es : ax }
+      width = @c.tty_columns
+      half = width / 2 - 2
+      wk = [wk, half].min
+      wv = [wv, half].min
+      re = (width - wk - wv)
+      wv += re if re > 0
+
+      h.each do |k, v|
+        @out.puts format('  %s%s', color_key(k, wk+1, prefix:prefix), color_value(v, wv))
+      end
+
+      self
+    end
+
+    # @return [String] human-readable CMDB prompt
+    def prompt(cmdb)
+      pwd = '/' + cmdb.pwd.join('/')
+      pwd = pwd[0...40] + '...' if pwd.size >= 40
+      'cmdb:' +
+        @c.green(pwd) +
+        @c.default('> ')
+    end
+
+    private
+
+    # Colorize a key and right-pad it to fit a minimum size. Append a ':'
+    # to make it YAML-esque.
+    def color_key(k, size, prefix:nil)
+      v = k.to_s
+      v.sub(prefix, '') if prefix && v.index(prefix) == 0
+      suffix = ':'
+      if v.size + 1 > size
+        v = v[0...size-4]
+        suffix = '...:'
+      end
+      pad = [0, size - v.size - suffix.size].max
+      @c.blue(v) << suffix << (' ' * pad)
+    end
+
+    # Colorize a value and right-pad it to fit a minimum size.
+    def color_value(v, size)
+      case v
+      when Symbol
+        vv = v.to_s
+      when nil
+        vv = 'null'
+      else
+        vv = v.inspect
+      end
+      vv << (' ' * [0, size - vv.size].max)
+
+      case v
+      when Symbol
+        @c.blue(vv)
+      when String
+        @c.bright_green(vv)
+      when Numeric
+        @c.bright_magenta(vv)
+      when true, false
+        @c.cyan(vv)
+      when nil
+        @c.yellow(vv)
+      when Array
+        str = @c.bold('[')
+        remain = size-2
+        v.each_with_index do |e, i|
+          ei = e.inspect
+          if remain >= ei.size + 3
+            str << ',' if i > 0
+            str << color_value(e, ei.size)
+          elsif remain >= 3
+            str << @c.default('...')
+            remain = 1
+          end
+          remain -= (ei.size + 1)
+        end
+        str << @c.bold(']')
+
+        str
+      else
+        @c.default(vv)
+      end
+
+    end
+  end
+end

data/lib/cmdb/shell/text.rb

@@ -0,0 +1,65 @@
+module CMDB::Shell
+  # Adapted from pry: https://github.com/pry/pry
+  class Text
+    COLORS = {
+      'black'   => 0,
+      'red'     => 1,
+      'green'   => 2,
+      'yellow'  => 3,
+      'blue'    => 4,
+      'purple'  => 5,
+      'magenta' => 5,
+      'cyan'    => 6,
+      'white'   => 7
+    }.freeze
+
+    def initialize(plain)
+      @plain = plain
+    end
+
+    COLORS.each_pair do |color, value|
+      define_method color do |text|
+        @plain && text || "\033[0;#{30+value}m#{text}\033[0m"
+      end
+
+      define_method "bright_#{color}" do |text|
+        @plain && text || "\033[1;#{30+value}m#{text}\033[0m"
+      end
+    end
+
+    # Remove any color codes from _text_.
+    #
+    # @param  [String, #to_s] text
+    # @return [String] _text_ stripped of any color codes.
+    def strip_color(text)
+      text.to_s.gsub(/\e\[.*?(\d)+m/ , '')
+    end
+
+    # Returns _text_ as bold text for use on a terminal.
+    #
+    # @param [String, #to_s] text
+    # @return [String] _text_
+    def bold(text)
+      @plain && text || "\e[1m#{text}\e[0m"
+    end
+
+    # Returns `text` in the default foreground colour.
+    # Use this instead of "black" or "white" when you mean absence of colour.
+    #
+    # @param [String, #to_s] text
+    # @return [String]
+    def default(text)
+      text.to_s
+    end
+    alias_method :bright_default, :bold
+
+    # @return [Integer] screen width (number of columns)
+    def tty_columns
+      if @plain
+        65_535
+      else
+        Integer(`stty size`.chomp.split(/ +/)[1]) rescue 80
+      end
+    end
+  end
+end

data/lib/cmdb/shell.rb

@@ -0,0 +1,8 @@
+module CMDB
+  module Shell
+  end
+end
+
+require 'cmdb/shell/dsl'
+require 'cmdb/shell/text'
+require 'cmdb/shell/printer'

data/lib/cmdb/source/consul.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+require 'base64'
+require 'net/http'
+require 'open-uri'
+
+module CMDB
+  class Source::Consul < Source::Network
+    # Regular expression to match array values
+    ARRAY_VALUE = /^\[(.*)\]$/
+
+    # Get a single key from consul. If the key is not found, return nil.
+    #
+    # @param [String] key dot-notation key
+    # @return [Object]
+    def get(key)
+      return nil unless prefixed?(key)
+      key = dot_to_slash(key)
+      response = http_get path_to(key)
+      case response
+      when String
+        response = json_parse(response)
+        item = response.first
+        json_parse(Base64.decode64(item['Value']))
+      when 404
+        nil
+      else
+        raise CMDB:Error.new("Unexpected consul response #{value.inspect}")
+      end
+    end
+
+    # Set a single key in consul. If value is nil, then delete the key
+    # entirely from consul.
+    #
+    # @param [String] key dot-notation key
+    # @param [Object] value new value of key
+    def set(key, value)
+      key = dot_to_slash(key)
+      if value.nil?
+        http_delete path_to(key)
+      else
+        http_put path_to(key), value
+      end
+    end
+
+    # Iterate through all keys in this source.
+    # @return [Integer] number of key/value pairs that were yielded
+    def each_pair(&_block)
+      path = path_to('/')
+
+      case result = http_get(path, query:'recurse')
+      when String
+        result = json_parse(result)
+      when 404
+        return # no keys!
+      end
+
+      unless result.is_a?(Array)
+        raise CMDB::Error.new("Consul 'GET #{path}': expected Array, got #{all.class.name}")
+      end
+
+      result.each do |item|
+        key = slash_to_dot(item['Key'])
+        value = json_parse(Base64.decode64(item['Value']))
+        yield(key, value)
+      end
+
+      result.size
+    end
+
+    # Test connectivity to consul agent.
+    #
+    # @return [Boolean]
+    def ping
+      http_get('/') == 'Consul Agent'
+    rescue
+      false
+    end
+
+    private
+
+    # Given a key's relative path, return its absolute REST path in the consul
+    # kv, including prefix if appropriate.
+    def path_to(subkey)
+      p = '/v1/kv/'
+      p << prefix << '/' if prefix
+      p << subkey unless (subkey == '/' && p[-1] == '/')
+      p
+    end
+  end
+end

data/lib/cmdb/{file_source.rb → source/file.rb}

@@ -2,42 +2,25 @@
 require 'uri'
 
 module CMDB
-  # Data source that is backed by a YAML file that lives in the filesystem. The name of the YAML
-  # file becomes the top-level key under which all values in the YAML are exposed, preserving
-  # their exact structure as parsed by YAML.
+  # Data source that is backed by a YAML/JSON file that lives in the filesystem. The name of the
+  # file becomes the top-level key under which all values in the file are exposed, preserving
+  # their exact structure as parsed by YAML/JSON.
   #
   # @example Use my.yml as a CMDB source
-  #    source = FileSource.new('/tmp/my.yml') # contains a top-level stanza named "database"
+  #    source = Source::File.new('/tmp/my.yml') # contains a top-level stanza named "database"
   #    source['my']['database']['host'] # => 'db1-1.example.com'
-  class FileSource
-    # @return [URI] a file:// URL describing where this source's data comes from
-    attr_reader :prefix, :url
-
-    @base_directories = ['/var/lib/cmdb', File.expand_path('~/.cmdb')]
-
-    # List of directories that will be searched (in order) for YML files at load time.
-    # @return [Array] collection of String
-    class << self
-      attr_reader :base_directories
-    end
-
-    # @param [Array] bd collection of String absolute paths to search for YML files
-    class << self
-      attr_writer :base_directories
-    end
-
-    # Construct a new FileSource from an input YML file.
-    # @param [String,Pathname] filename path to a YAML file
-    # @param [String] root optional subpath in data to "mount"
+  class Source::File < Source
+    # Construct a new Source::File from an input file.
+    # @param [String,Pathname] filename path to a file
     # @param [String] prefix optional prefix of
     # @raise [BadData] if the file's content is malformed
-    def initialize(filename, root = nil, prefix = File.basename(filename, '.*'))
+    def initialize(filename, prefix)
       @data = {}
       @prefix = prefix
-      filename = File.expand_path(filename)
+      filename = ::File.expand_path(filename)
       @url = URI.parse("file://#{filename}")
-      @extension = File.extname(filename)
-      raw_bytes = File.read(filename)
+      @extension = ::File.extname(filename)
+      raw_bytes = ::File.read(filename)
       raw_data  = nil
 
       begin
@@ -53,32 +36,30 @@ module CMDB
         raise BadData.new(url, 'CMDB data file')
       end
 
-      raw_data = raw_data[root] if !root.nil? && raw_data.key?(root)
       flatten(raw_data, @prefix, @data)
     end
 
     # Get the value of key.
     #
-    # @return [nil,String,Numeric,TrueClass,FalseClass,Array] the key's value, or nil if not found
+    # @return [Object] the key's value, or nil if not found
     def get(key)
       @data[key]
     end
 
-    # Enumerate the keys in this source, and their values.
+    # Enumerate the keys and values in this source.
     #
     # @yield every key/value in the source
     # @yieldparam [String] key
     # @yieldparam [Object] value
     def each_pair(&_block)
-      # Strip the prefix in the key and call the block
-      @data.each_pair { |k, v| yield(k.split("#{@prefix}.").last, v) }
+      @data.each_pair { |k, v| yield(k, v) }
     end
 
     private
 
     def flatten(data, prefix, output)
       data.each_pair do |key, value|
-        key = "#{prefix}.#{key}"
+        key = "#{prefix}#{CMDB::SEPARATOR}#{key}"
         case value
         when Hash
           flatten(value, key, output)

data/lib/cmdb/source/memory.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require 'uri'
+
+module CMDB
+  # Data source that is backed by the an in-memory Ruby hash; used solely for
+  # testing.
+  class Source::Memory
+    # @return [String] the empty string
+    attr_reader :prefix
+
+    # Construct a new Source::Hahs.
+    def initialize(hash, prefix)
+      @hash = hash
+      @prefix = prefix
+    end
+
+    # Get the value of key.
+    #
+    # @return [nil,String,Numeric,TrueClass,FalseClass,Array] the key's value, or nil if not found
+    def get(key)
+      @hash[key]
+    end
+
+    # Set the value of a key.
+    def set(key, value)
+      value = JSON.dump(value) unless value.is_a?(String)
+      @hash[key] = value
+    end
+
+    # Enumerate the keys in this source, and their values.
+    #
+    # @yield every key/value in the source
+    # @yieldparam [String] name of key
+    # @yieldparam [Object] value of key
+    def each_pair(&block)
+      @hash.each_pair(&block)
+    end
+  end
+end