cmdb 2.6.2 → 3.0.0rc1

data/docker-compose.yml

@@ -0,0 +1,15 @@
+version: "2"
+networks:
+  default:
+    ipam:
+      config:
+        - subnet: 172.28.0.0/24
+services:
+  consul:
+    command: "agent -client=172.28.0.2 -bootstrap -server"
+    image: consul
+    networks:
+      default:
+        ipv4_address: 172.28.0.2
+    ports:
+      - "8500"

data/exe/cmdb

@@ -20,37 +20,64 @@ CMDB::Commands.constants.each do |konst|
   commands[name] = CMDB::Commands.const_get(konst.to_sym)
 end
 
-# Use a Trollop parser for help/banner display, but do not actually parse
-# anything just yet.
 command_list = commands.keys - ['help']
 command_info = command_list.map { |c| "       * #{c}" }.join("\n")
+
+# Use a Trollop parser for help/banner display, but do not actually parse
+# anything just yet.
 p = Trollop::Parser.new do
   version "cmdb #{gemspec_version} (c) 2013-2014 RightScale, Inc."
   banner <<-EOS
 A command-line interface for configuration management.
 
 Usage:
-       cmdb <command> [options]
+       cmdb [options] <command> [command-options]
 
 Where <command> is one of:
 #{command_info}
 
-To get help on a command:
-       cmdb help command
+To get help on a specific command and its options:
+       cmdb help <command>
+
+Common options that apply to all commands:
   EOS
 
+  opt :source,
+      "Source of CMDB inputs e.g. file:///foo.yml or consul://localhost",
+      type: :string,
+      multi: true
+
+  opt :quiet,
+      "Suppress unnecessary output",
+      default: false
+
   stop_on commands.keys
 end
 
 Trollop.with_standard_exception_handling p do
   raise Trollop::HelpNeeded if ARGV.empty?
-  p.parse ARGV
+
+  # Apply global options
+  options = p.parse ARGV
+  CMDB.log.level = Logger::FATAL if options[:quiet]
+
+  if options[:source].empty?
+    sources = CMDB::Source.detect
+  else
+    sources = options[:source].map do |source|
+      CMDB::Source.create(source)
+    end
+  end
+
+  interface = CMDB::Interface.new(*sources)
+
+  # Identify the subcommand and run it (or print help).
+  raise Trollop::HelpNeeded if ARGV.empty?
   cmd = ARGV.shift
   klass = commands[cmd]
-
   if klass
-    klass.create.run
+    klass.create(interface).run
   else
-    raise(ArgumentError, "Unrecognized command #{cmd}")
+    CMDB.log.fatal "Unrecognized command '#{cmd}'; try 'cmdb --help'"
   end
 end

data/lib/cmdb/commands/help.rb

@@ -1,77 +1,32 @@
 # encoding: utf-8
-require 'logger'
-require 'listen'
 
 module CMDB::Commands
   class Help
-    def self.create
-      options = Trollop.options do
-        banner <<-EOS
-The 'shim' command adapts your applications for use with CMDB without coupling them to
-the CMDB RubyGem (or forcing you to write your applications in Ruby). It works by
-manipulating the environment or filesystem to make CMDB inputs visible, then invoking
-your app.
-
-To use the shim with apps that read configuration from the filesystem, use the --dir
-option to tell the shim where to rewrite configuration files. It will look for tokens
-in JSON or YML that look like <<cmdb.key.name>> and replace them with the value of
-the specified key.
-
-To use the shim with 12-factor apps, use the --env option to tell the shim to load
-every CMDB key into the environment. When using --env, the prefix of each key is
-omitted from the environment variable name, e.g. "common.database.host" is
-represented as DATABASE_HOST.
-
-To support "development mode" and reload your app whenever its files change on disk,
-use the --reload option and specify the name of a CMDB key that will enable this
-behavior.
-
-Usage:
-cmdb shim [options] -- <command_to_exec> [options_for_command]
-
-Where [options] are selected from:
-        EOS
-        opt :dir,
-            'Directory to scan for key-replacement tokens in data files',
-            type: :string
-        opt :consul_url,
-            'The URL for talking to consul',
-            type: :string
-        opt :consul_prefix,
-            'The prefix to use when getting keys from consul, can be specified more than once',
-            type: :string,
-            multi: true
-        opt :keys,
-            'Override search path(s) for CMDB key files',
-            type: :strings
-        opt :pretend,
-            'Check for errors, but do not actually launch the app or rewrite files',
-            default: false
-        opt :quiet,
-            "Don't print any output",
-            default: false
-        opt :reload,
-            'CMDB key that enables reload-on-edit',
-            type: :string
-        opt :reload_signal,
-            'Signal to send to app server when code is edited',
-            type: :string,
-            default: 'HUP'
-        opt :env,
-            "Add CMDB keys to the app server's process environment",
-            default: false
-        opt :user,
-            'Switch to named user before executing app',
-            type: :string
-        opt :root,
-            'Promote named subkey to the root when it is present in a namespace',
-            type: :string
-      end
+    def self.create(interface)
+      new(interface, ARGV.first)
+    end
 
-      new(ARGV, options)
+    def initialize(interface, command)
+      @cmdb = interface
+      @command = command
     end
 
     def run
+      if @command.nil? || @command.empty?
+        # Same as "--help"
+        raise Trollop::HelpNeeded
+      end
+
+      # Find the command the user was talking about and print some help
+      konst = CMDB::Commands.constants.detect { |konst| konst.to_s.downcase == @command }
+      if konst
+        klass = CMDB::Commands.const_get(konst)
+        ARGV.clear ; ARGV.push('--help')
+        klass.create(@cmdb)
+      else
+        CMDB.log.fatal "CMDB: Unknown command '#{@command}'; try 'cmdb --help' for a list of commands"
+        exit 1
+      end
     end
   end
 end

data/lib/cmdb/commands/shell.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+module CMDB::Commands
+  class Shell
+    # Character that acts as a separator between key components. The standard
+    # notation uses `.` but Shell allow allows `/` for a more filesystem-like
+    # user experience.
+    ALT_SEPARATOR = '/'.freeze
+
+    # Directory navigation shortcuts ('.' and '..')
+    NAVIGATION = /^#{Regexp.escape(CMDB::SEPARATOR + CMDB::SEPARATOR)}?$/.freeze
+
+    def self.create(interface)
+      require 'cmdb/shell'
+
+      options = Trollop.options do
+        banner <<-EOS
+The 'shell' command enters a Unix-like shell where you can interact with
+CMDB sources and inspect the value of keys.
+
+Usage:
+cmdb shell
+        EOS
+      end
+
+      new(interface)
+    end
+
+    # @return [CMDB::Interface]
+    attr_reader :cmdb
+
+    # @return [Array] the "present working directory" (i.e. key prefix) for shell commands
+    attr_accessor :pwd
+
+    # @return [Object] esult of the most recent command
+    attr_accessor :_
+
+    # @param [CMDB::Interface] interface
+    def initialize(interface)
+      @cmdb = interface
+      @pwd = []
+      @out = CMDB::Shell::Printer.new
+    end
+
+    # Run the shim.
+    #
+    # @raise [SystemExit] if something goes wrong
+    def run
+      @dsl = CMDB::Shell::DSL.new(self, @out)
+      repl
+    end
+
+    # Given a key name/prefix relative to `pwd`, return the absolute
+    # name/prefix. If `pwd` is empty, just return `subpath`. The subpath
+    # can use either dotted or slash notation, and directory navigation
+    # symbols (`.` and `..`) are applied as expected if the subpath uses
+    # slash notation.
+    #
+    # @return [String] absolute key in dotted notation
+    def expand_path(subpath)
+      pieces = subpath.split(ALT_SEPARATOR)
+
+      if subpath[0] == ALT_SEPARATOR
+        result = []
+      else
+        result = pwd.dup
+      end
+
+      if subpath.include?(ALT_SEPARATOR) || subpath =~ NAVIGATION
+        # filesystem-like subpath
+        # apply Unix-style directory navigation shortcuts
+        pieces.each do |piece|
+          case piece
+          when '..' then result.pop
+          when '.' then nil
+          else result.push(piece)
+          end
+        end
+
+        result.join(CMDB::SEPARATOR)
+      else
+        # standard dotted notation
+        result += pieces
+      end
+
+      result.join(CMDB::SEPARATOR)
+    end
+
+    private
+
+    def repl
+      require 'readline'
+      while line = Readline.readline(@out.prompt(self), true)
+        begin
+          line = line.chomp
+          next if line.nil? || line.empty?
+          words = line.split(/\s+/)
+          command, args = words.first.to_sym, words[1..-1]
+
+          run_ruby(command, args) || run_getter(line) || run_setter(line) ||
+            fail(CMDB::BadCommand.new(command))
+          handle_output(self._)
+        rescue => e
+          handle_error(e) || raise
+        end
+      end
+    rescue Interrupt
+      return 0
+    end
+
+    # @return [Boolean] true if line was handled as a normal command
+    def run_ruby(command, args)
+      self._ = @dsl.__send__(command, *args)
+      true
+    rescue NoMethodError
+      false
+    rescue ArgumentError => e
+      raise CMDB::BadCommand.new(e.message, command)
+    end
+
+    # @return [Boolean] true if line was handled as a getter
+    def run_getter(key)
+      if value = @dsl.get(key)
+        self._ = value
+        true
+      else
+        false
+      end
+    rescue CMDB::Error
+      false
+    end
+
+    # @return [Boolean] true if line was handled as a setter
+    def run_setter(line)
+      key, value = line.strip.split(/\s*=\s*/, 2)
+      return false unless key && value
+
+      value = nil unless value && value.length > 0
+      self._ = @dsl.set(key, value)
+      true
+    rescue CMDB::Error
+      false
+    end
+
+    def handle_output(obj)
+      case obj
+      when Hash
+        @out.keys_values(obj)
+      else
+        @out.value(obj)
+      end
+    end
+
+    # @return [Boolean] print message and return true if error is handled; else return false
+    def handle_error(e)
+      case e
+      when CMDB::BadCommand
+        @out.error "#{e.command}: #{e.message}"
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/cmdb/commands/shim.rb

@@ -1,10 +1,8 @@
 # encoding: utf-8
-require 'logger'
-require 'listen'
 
 module CMDB::Commands
   class Shim
-    def self.create
+    def self.create(interface)
       options = Trollop.options do
         banner <<-EOS
 The 'shim' command adapts your applications for use with CMDB without coupling them to
@@ -12,7 +10,7 @@ the CMDB RubyGem (or forcing you to write your applications in Ruby). It works b
 manipulating the environment or filesystem to make CMDB inputs visible, then invoking
 your app.
 
-To use the shim with apps that read configuration from the filesystem, use the --dir
+To use the shim with apps that read configuration from the filesystem, use the --rewrite
 option to tell the shim where to rewrite configuration files. It will look for tokens
 in JSON or YML that look like <<cmdb.key.name>> and replace them with the value of
 the specified key.
@@ -22,53 +20,28 @@ every CMDB key into the environment. When using --env, the prefix of each key is
 omitted from the environment variable name, e.g. "common.database.host" is
 represented as DATABASE_HOST.
 
-To support "development mode" and reload your app whenever its files change on disk,
-use the --reload option and specify the name of a CMDB key that will enable this
-behavior.
-
 Usage:
 cmdb shim [options] -- <command_to_exec> [options_for_command]
 
 Where [options] are selected from:
         EOS
-        opt :dir,
+        opt :rewrite,
             'Directory to scan for key-replacement tokens in data files',
             type: :string
-        opt :consul_url,
-            'The URL for talking to consul',
-            type: :string
-        opt :consul_prefix,
-            'The prefix to use when getting keys from consul, can be specified more than once',
-            type: :string,
-            multi: true
-        opt :keys,
-            'Override search path(s) for CMDB key files',
-            type: :strings
         opt :pretend,
             'Check for errors, but do not actually launch the app or rewrite files',
             default: false
-        opt :quiet,
-            "Don't print any output",
-            default: false
-        opt :reload,
-            'CMDB key that enables reload-on-edit',
-            type: :string
-        opt :reload_signal,
-            'Signal to send to app server when code is edited',
-            type: :string,
-            default: 'HUP'
         opt :env,
             "Add CMDB keys to the app server's process environment",
             default: false
         opt :user,
             'Switch to named user before executing app',
             type: :string
-        opt :root,
-            'Promote named subkey to the root when it is present in a namespace',
-            type: :string
       end
+      options.delete(:help)
 
-      new(ARGV, options)
+      options.delete_if { |k, v| k.to_s =~ /_given$/i }
+      new(interface, ARGV, **options)
     end
 
     # Irrevocably change the current user for this Unix process by calling the
@@ -90,35 +63,18 @@ Where [options] are selected from:
 
     # Create a Shim.
     # @param [Array] command collection of string to pass to Kernel#exec; 0th element is the command name
-    # @options [String] :condif_dir
-    def initialize(command, options = {})
+    def initialize(interface, command, rewrite:, pretend:, user:)
+      @cmdb            = interface
       @command         = command
-      @dir             = options[:dir]
-      @consul_url      = options[:consul_url]
-      @consul_prefixes = options[:consul_prefix]
-      @keys            = options[:keys] || []
-      @pretend         = options[:pretend]
-      @reload          = options[:reload]
-      @signal          = options[:reload_signal]
-      @env             = options[:env]
-      @user            = options[:user]
-      @root            = options[:root]
-
-      CMDB::FileSource.base_directories = @keys unless @keys.empty?
-      CMDB::ConsulSource.url = @consul_url unless @consul_url.nil?
-      if !@consul_prefixes.nil? && !@consul_prefixes.empty?
-        CMDB::ConsulSource.prefixes = @consul_prefixes
-      end
-
-      CMDB.log.level = Logger::FATAL if options[:quiet]
+      @dir             = rewrite
+      @pretend         = pretend
+      @user            = user
     end
 
     # Run the shim.
     #
     # @raise [SystemExit] if something goes wrong
     def run
-      @cmdb = CMDB::Interface.new(root: @root)
-
       rewrote   = rewrite_files
       populated = populate_environment
 
@@ -187,8 +143,6 @@ Where [options] are selected from:
 
     # @return [Boolean]
     def populate_environment
-      return false unless @env
-
       env = @cmdb.to_h
 
       env.keys.each do |k|
@@ -207,81 +161,12 @@ Where [options] are selected from:
 
     def launch_app
       if @command.any?
-        # log this now, so that it gets logged even if @pretend
         CMDB.log.info "App will run as user #{@user}" if @user
-
-        if @reload && @cmdb.get(@reload)
-          CMDB.log.info "SIG#{@signal}-on-edit is enabled; fork app"
-          fork_and_watch_app unless @pretend
-        else
-          CMDB.log.info "SIG#{@signal}-on-edit is disabled; exec app"
-          exec_app unless @pretend
-        end
+        self.class.drop_privileges(@user) if @user
+        exec(*@command)
       end
     end
 
-    def exec_app
-      self.class.drop_privileges(@user) if @user
-      exec(*@command)
-    end
-
-    def fork_and_watch_app
-      # let the child share our stdio handles on purpose
-      pid = fork do
-        exec_app
-      end
-
-      CMDB.log.info('App (pid %d) has been forked; watching %s' % [pid, ::Dir.pwd])
-
-      t0 = Time.at(0)
-
-      listener = Listen.to(::Dir.pwd) do |modified, added, removed|
-        modified = modified.select { |fn| interesting?(fn) }
-        added = added.select { |fn| interesting?(fn) }
-        removed = removed.select { |fn| interesting?(fn) }
-        next if modified.empty? && added.empty? && removed.empty?
-
-        begin
-          dt = Time.now - t0
-          if dt > 15
-            Process.kill(@signal, pid)
-            CMDB.log.info 'Sent SIG%s to app (pid %d) because (modified,created,deleted)=(%d,%d,%d)' %
-                          [@signal, pid, modified.size, added.size, removed.size]
-            t0 = Time.now
-          else
-            CMDB.log.error 'Skipped SIG%s to app (pid %d) due to timeout (%d)' %
-                           [@signal, pid, dt]
-          end
-        rescue
-          CMDB.log.error 'Skipped SIG%s to app (pid %d) due to %s' %
-                         [@signal, pid, $ERROR_INFO.to_s]
-        end
-      end
-
-      listener.start
-
-      wpid = nil
-      wstatus = nil
-
-      loop do
-        begin
-          wpid, wstatus = Process.wait2(-1, Process::WNOHANG)
-          if wpid
-            break if wstatus.exited?
-            CMDB.log.info('Descendant (pid %d) has waited with %s' % [wpid, wstatus.inspect])
-          end
-        rescue
-          CMDB.log.error 'Skipped wait2 to app (pid %d) due to %s' %
-                         [pid, $ERROR_INFO.to_s]
-        end
-        sleep(1)
-      end
-
-      CMDB.log.info('App (pid %d) has exited with %s' % [wpid, wstatus.inspect])
-      listener.stop
-      exit(wstatus.exitstatus || 43)
-    end
-
     def report_rewrite(total)
       CMDB.log.info "Replaced #{total} variables in #{@dir}"
     end

data/lib/cmdb/commands.rb

@@ -5,4 +5,5 @@ module CMDB
 end
 
 require 'cmdb/commands/help'
+require 'cmdb/commands/shell'
 require 'cmdb/commands/shim'