rzo 0.1.0 → 0.2.0

data/lib/rzo/app/generate.rb

@@ -0,0 +1,137 @@
+require 'rzo/app/subcommand'
+require 'pp'
+require 'erb'
+
+module Rzo
+  class App
+    ##
+    # Produce a `Vagrantfile` in the top level puppet control repo.
+    #
+    # Load all rizzo config files, then produce the Vagrantfile from an ERB
+    # template.
+    class Generate < Subcommand
+      attr_reader :config
+
+      # The main run method for the subcommand.
+      def run
+        exit_status = 0
+        load_config!
+        # Vagrantfile
+        erbfile = File.expand_path('../templates/Vagrantfile.erb', __FILE__)
+        content = vagrantfile_content(erbfile, config)
+        write_file(opts[:vagrantfile]) { |fd| fd.write(content) }
+        say "Wrote vagrant config to #{opts[:vagrantfile]}"
+        exit_status
+      end
+
+      ##
+      # Return a list of agent node definitions suitable for the Vagrantfile
+      # template.
+      #
+      # @param [Hash] config The configuration hash used to fill in the ERB
+      # template.
+      #
+      # @return [Array<Hash>] list of agent nodes to fill in the Vagrantfile
+      # template.
+      def vagrantfile_agents(config)
+        pm_settings = puppetmaster_settings(config)
+        agent_nodes = [*config['nodes']].reject do |n|
+          pm_settings['name'].include?(n['name'])
+        end
+
+        agent_nodes.each do |n|
+          n.deep_merge(config['defaults'])
+          log.debug "puppetagent #{n['name']} = \n" + n.pretty_inspect
+        end
+
+        agent_nodes
+      end
+
+      ##
+      # Return a list of puppetmaster node definitions suitable for the
+      # Vagrantfile template.
+      #
+      # @param [Hash] config The configuration hash used to fill in the ERB
+      # template.
+      #
+      # @return [Array<Hash>] list of puppet master nodes to fill in the
+      # Vagrantfile template.
+      #
+      # rubocop:disable Metrics/AbcSize
+      def vagrantfile_puppet_masters(config)
+        pm_settings = puppetmaster_settings(config)
+        pm_names = pm_settings['name']
+
+        nodes = [*config['nodes']].find_all { |n| pm_names.include?(n['name']) }
+        nodes.each do |n|
+          n.deep_merge(config['defaults'])
+          n.deep_merge(pm_settings)
+          n[:puppetmaster] = true
+          log.debug "puppetmaster #{n['name']} = \n" + n.pretty_inspect
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      ##
+      # Return the proxy configuration exception list as a string, or nil if not set.
+      #
+      # @param [Hash] config The configuration hash used to fill in the ERB
+      # template.
+      #
+      # @return [String,nil] proxy exclusion list or nil if not specified.
+      def proxy_config(config)
+        # Proxy Setting
+        return nil unless config['config']
+        config['config']['no_proxy'] || DEFAULT_NO_PROXY
+      end
+
+      ##
+      # Return a timestamp to embed in the output Vagrantfile.  This is a method
+      # so it may be stubbed out in the tests.
+      def timestamp
+        Time.now
+      end
+
+      ##
+      # Return a string which is the Vagrantfile content of a filled in
+      # Vagrantfile erb template.  The configuration data parsed by load_config!
+      # is expected as input, along with the template to fill in.
+      #
+      # The base templates directory is relative to the directory containing
+      # this file.
+      #
+      # @param [String] template The fully qualified path to the ERB template.
+      #
+      # @param [Hash] config The configuration hash used to fill in the ERB
+      # template.
+      #
+      # @return [String] the content of the filled in template.
+      def vagrantfile_content(template, config)
+        renderer = ERB.new(File.read(template), 0, '-')
+
+        no_proxy = proxy_config(config)
+
+        # Agent nodes [Array<Hash>]
+        agent_nodes = vagrantfile_agents(config)
+        # Puppet Master nodes [Array<Hash>]
+        puppet_master_nodes = vagrantfile_puppet_masters(config)
+
+        # nodes is used by the Vagrantfile.erb template
+        nodes = [*puppet_master_nodes, *agent_nodes]
+        content = renderer.result(binding)
+        content
+      end
+
+      ##
+      # dump out the puppetmaster settings from the config.
+      def puppetmaster_settings(config)
+        log.debug "config['puppetmaster'] = \n" + \
+          config['puppetmaster'].pretty_inspect
+        config['puppetmaster']
+      end
+
+      # Constants used by the Vagrantfile.erb template.
+      DEFAULT_NO_PROXY = 'localhost,127.0.0.1'.freeze
+    end
+  end
+end

data/lib/rzo/app/subcommand.rb

@@ -0,0 +1,172 @@
+require 'rzo/logging'
+require 'deep_merge'
+module Rzo
+  class App
+    # The base class for subcommands
+    class Subcommand
+      include Logging
+      extend Logging
+      # The options hash injected from the application controller via the
+      # initialize method.
+      attr_reader :opts
+      # The Rizzo configuration after loading ~/.rizzo.json (--config).
+      # See #load_config!
+      attr_reader :config
+
+      ##
+      # Delegated method to mock with fixture data.
+      def self.load_rizzo_config(fpath)
+        config_file = Pathname.new(fpath).expand_path
+        raise ErrorAndExit, "Cannot read config file #{config_file}" unless config_file.readable?
+        config = JSON.parse(config_file.read)
+        log.debug "Loaded #{config_file}"
+        config
+      rescue JSON::ParserError => e
+        raise ErrorAndExit, "Could not parse rizzo config #{config_file} #{e.message}"
+      end
+
+      # Initialize a subcommand with options injected by the application
+      # controller.
+      #
+      # @param [Hash] opts the Options hash initialized by the Application
+      # controller.
+      def initialize(opts = {}, stdout = $stdout, stderr = $stderr)
+        @opts = opts
+        @stdout = stdout
+        @stderr = stderr
+        reset_logging!(opts)
+      end
+
+      ##
+      # Default run method.  Override this method in a subcommand sub-class
+      #
+      # @return [Fixnum] the exit status of the subcommand.
+      def run
+        error "Implement the run method in subclass #{self.class}"
+        1
+      end
+
+      private
+
+      ##
+      # Load rizzo configuration.  Populate @config.
+      #
+      # Read rizzo configuration by looping through control repos and stopping
+      # at first match and merge on top of local, defaults (~/.rizzo.json)
+      def load_config!
+        config = load_rizzo_config(opts[:config])
+        validate_config(config)
+        repos = config['control_repos']
+        @config = load_repo_configs(config, repos)
+        debug "Merged configuration: \n#{JSON.pretty_generate(@config)}"
+        validate_forwarded_ports(@config)
+        validate_ip_addresses(@config)
+        @config
+      end
+
+      ##
+      # Given a list of repository paths, load .rizzo.json from the root of each
+      # repository and return the result merged onto config.  The merging
+      # behavior is implemented by
+      # [deep_merge](http://www.rubydoc.info/gems/deep_merge/1.1.1)
+      #
+      # @param [Hash] config the starting config hash.  Repo config maps will be
+      #   merged on top of this starting map.
+      #
+      # @param [Array] repos the list of repositories to load .rizzo.json from.
+      #
+      # @return [Hash] the merged configuration hash.
+      def load_repo_configs(config = {}, repos = [])
+        repos.each_with_object(config.dup) do |repo, hsh|
+          fp = Pathname.new(repo).expand_path + '.rizzo.json'
+          if fp.readable?
+            hsh.deep_merge!(load_rizzo_config(fp))
+          else
+            log.debug "Skipped #{fp} (it is not readable)"
+          end
+        end
+      end
+
+      ##
+      # Basic validation of the configuration file content.
+      #
+      # @param [Hash] config the configuration map
+      def validate_config(config)
+        errors = []
+        errors.push 'control_repos key is not an Array' unless config['control_repos'].is_a?(Array)
+        errors.each { |l| log.error l }
+        raise ErrorAndExit, 'Errors found in config file.  Cannot proceed.' unless errors.empty?
+      end
+
+      ##
+      # Check for duplicate forwarded host ports across all hosts and exit
+      # non-zero with an error message if found.
+      def validate_forwarded_ports(config)
+        host_ports = []
+        [*config['nodes']].each do |node|
+          [*node['forwarded_ports']].each do |hsh|
+            port = hsh['host'].to_i
+            raise_port_err(port, node['name']) if host_ports.include?(port)
+            host_ports.push(port)
+          end
+        end
+        log.debug "host_ports = #{host_ports}"
+      end
+
+      ##
+      # Check for duplicate forwarded host ports across all hosts and exit
+      # non-zero with an error message if found.
+      def validate_ip_addresses(config)
+        ips = []
+        [*config['nodes']].each do |node|
+          if ip = node['ip']
+            raise_ip_err(ip, node['name']) if ips.include?(ip)
+            ips.push(ip)
+          end
+        end
+        log.debug "ips = #{ips}"
+      end
+
+      ##
+      # Helper to raise a duplicate port error
+      def raise_port_err(port, node)
+        raise ErrorAndExit, "host port #{port} on node #{node} " \
+          'is a duplicate.  Ports must be unique.  Check .rizzo.json ' \
+          'files in each control repository for duplicate forwarded_ports entries.'
+      end
+
+      ##
+      # Helper to raise a duplicate port error
+      def raise_ip_err(ip, node)
+        raise ErrorAndExit, "host ip #{ip} on node #{node} " \
+          'is a duplicate.  IP addresses must be unique.  Check .rizzo.json ' \
+          'files in each control repository for duplicate ip entries'
+      end
+
+      ##
+      # Load the base configuration and return it as a hash.  This is necessary
+      # to get access to the `'control_repos'` top level key, which is expected
+      # to be an Array of fully qualified paths to control repo base
+      # directories.
+      #
+      # @param [String] fpath The fully qualified path to the configuration file
+      #   to load.
+      #
+      # @return [Hash] The configuration map
+      def load_rizzo_config(fpath)
+        self.class.load_rizzo_config(fpath)
+      end
+
+      ##
+      # Write a file by yielding a file descriptor to the passed block.  In the
+      # case of opening a file, the FD will automatically be closed.
+      def write_file(filepath)
+        case filepath
+        when 'STDOUT' then yield @stdout
+        when 'STDERR' then yield @stderr
+        else File.open(filepath, 'w') { |fd| yield fd }
+        end
+      end
+    end
+  end
+end

data/lib/rzo/app/templates/Vagrantfile.erb

@@ -0,0 +1,55 @@
+# This file generated with Rizzo <%= Rzo.version %> on <%= timestamp %>
+# https://github.com/ghoneycutt/rizzo
+Vagrant.configure(2) do |config|
+  # use 'vagrant plugin install vagrant-proxyconf' to install
+  if Vagrant.has_plugin?('vagrant-proxyconf')
+    config.proxy.http  = ENV['HTTP_PROXY']  if ENV['HTTP_PROXY']
+    config.proxy.https = ENV['HTTPS_PROXY'] if ENV['HTTPS_PROXY']
+    <%- if no_proxy -%>
+    config.proxy.no_proxy = <%= no_proxy.inspect %>
+    <%- end -%>
+  end
+  <%- nodes.each do |nc| -%>
+
+  config.vm.define <%= nc['name'].inspect %>, autostart: false do |cfg|
+    cfg.vm.box = <%= nc['box'].inspect %>
+    cfg.vm.box_url = <%= nc['box_url'].inspect %>
+    cfg.vm.box_download_checksum = <%= nc['box_download_checksum'].inspect %>
+    cfg.vm.box_download_checksum_type = <%= nc['box_download_checksum_type'].inspect %>
+    cfg.vm.provider :virtualbox do |vb|
+      vb.customize ['modifyvm', :id, '--memory', <%= nc['memory'].inspect %>]
+    end
+    cfg.vm.hostname = <%= nc['hostname'].inspect %>
+    cfg.vm.network 'private_network',
+      ip: <%= nc['ip'].inspect %>,
+      netmask: <%= nc['netmask'].inspect %>
+    <%- [*nc['forwarded_ports']].each do |forwarded_port| -%>
+    cfg.vm.network 'forwarded_port',
+      guest: <%= forwarded_port['guest'].inspect %>,
+      host: <%= forwarded_port['host'].inspect %>
+    <%- end -%>
+    <%- synced_folders = nc['synced_folders'] || {} -%>
+    <%- synced_folders.each_pair do |k, v| -%>
+    cfg.vm.synced_folder <%= v['local'].inspect %>, <%= k.inspect %>,
+      owner: <%= v['owner'].inspect %>, group: <%= v['group'].inspect %>
+    <%- end -%>
+    <%- if nc['bootstrap_repo_path'] -%>
+    config.vm.synced_folder <%= nc['bootstrap_repo_path'].inspect %>,
+      <%= nc['bootstrap_guest_path'].inspect %>,
+      owner: 'vagrant', group: 'root'
+    <%- if nc[:puppetmaster] -%>
+    config.vm.provision 'shell', inline: <%= "echo 'modulepath = #{nc['modulepath'].join(':')}' > #{nc['bootstrap_guest_path']}/environment.conf".inspect %>
+    <%- end -%>
+    config.vm.provision 'shell', inline: <%= "/bin/bash #{nc['bootstrap_guest_path']}/#{nc['bootstrap_script_path']} #{nc['bootstrap_script_args']}".inspect %>
+    <%- if nc['update_packages'] -%>
+    config.vm.provision 'shell', inline: <%= nc['update_packages_command'].inspect %>
+    <%- end -%>
+    <%- if nc['shutdown'] -%>
+    config.vm.provision 'shell', inline: <%= nc['shutdown_command'].inspect %>
+    <%- end -%>
+    <%- end -%>
+  end
+  <%- end -%>
+end
+# -*- mode: ruby -*-
+# vim:ft=ruby

data/lib/rzo/app.rb

@@ -0,0 +1,92 @@
+require 'rzo'
+require 'rzo/logging'
+require 'rzo/option_parsing'
+require 'rzo/app/config'
+require 'rzo/app/generate'
+require 'json'
+
+module Rzo
+  ##
+  # The application controller.  An instance of this class models the
+  # application lifecycle.  Input configuration follows the 12 factor model.
+  #
+  # The general lifecycle is:
+  #
+  #  * app = App.new()
+  #  * app.parse_options!
+  #  * app.run
+  class App
+    include Rzo::Logging
+    include Rzo::OptionParsing
+
+    ##
+    # Exception used to exit the app from a subcommand.  Caught by the main run
+    # method in the app controller
+    class ErrorAndExit < StandardError
+      attr_accessor :exit_status
+      def initialize(message = nil, exit_status = 1)
+        super(message)
+        self.exit_status = exit_status
+      end
+    end
+
+    ##
+    # @param [Array] argv The argument vector, passed to the option parser.
+    #
+    # @param [Hash] env The environment hash, passed to the option parser to
+    #   supply defaults not specified on the command line argument vector.
+    #
+    # @return [App] the application instance.
+    def initialize(argv = ARGV.dup, env = ENV.to_hash, stdout = $stdout, stderr = $stderr)
+      @argv = argv
+      @env = env
+      @stdout = stdout
+      @stderr = stderr
+      reset!
+    end
+
+    ##
+    # Reset all state associated with this application instance.
+    def reset!
+      reset_options!
+      reset_logging!(opts)
+      @api = nil
+    end
+
+    ##
+    # Accessor to Subcommand::Generate
+    def generate
+      @generate ||= Generate.new(opts, @stdout, @stderr)
+    end
+
+    ##
+    # Override this later to allow trollop to write to an intercepted file
+    # descriptor for testing.  This will avoid trollop's behavior of calling
+    # exit()
+    def educate
+      Trollop.educate
+    end
+
+    ##
+    # The main application run method
+    #
+    # @return [Fixnum] the system exit code
+    #
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def run
+      case opts[:subcommand]
+      when 'config'
+        Config.new(opts, @stdout, @stderr).run
+      when 'generate'
+        generate.run
+      else
+        educate
+      end
+    rescue ErrorAndExit => e
+      log.error e.message
+      e.backtrace.each { |l| log.debug(l) }
+      e.exit_status
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+  end
+end

data/lib/rzo/logging.rb

@@ -0,0 +1,144 @@
+require 'logger'
+require 'stringio'
+require 'syslog/logger'
+module Rzo
+  ##
+  # Support module to mix into a class for consistent logging behavior.
+  module Logging
+    ##
+    # Reset the global logger instance and return it as an object.
+    #
+    # @return [Logger] initialized logging instance
+    def self.reset_logging!(opts)
+      logger = opts[:syslog] ? syslog_logger : stream_logger(opts)
+      @log = logger
+    end
+
+    ##
+    # Return a new Syslog::Logger instance configured for syslog output
+    def self.syslog_logger
+      # Use the daemon facility, matching Puppet behavior.
+      Syslog::Logger.new('rzo', Syslog::LOG_DAEMON)
+    end
+
+    ##
+    # Return a new Logger instance configured for file output
+    def self.stream_logger(opts)
+      out = map_file_option(opts[:logto])
+      logger = Logger.new(out)
+      logger.level = Logger::WARN
+      logger.level = Logger::INFO if opts[:verbose]
+      logger.level = Logger::DEBUG if opts[:debug]
+      logger
+    end
+
+    ##
+    # Logging is handled centrally, the helper methods will delegate to the
+    # centrally configured logging instance.
+    def self.log
+      @log || reset_logging!(opts)
+    end
+
+    ##
+    # Map a file option to STDOUT, STDERR or a fully qualified file path.
+    #
+    # @param [String] filepath A relative or fully qualified file path, or the
+    #   keyword strings 'STDOUT' or 'STDERR'
+    #
+    # @return [String] file path or $stdout or $sederr
+    def self.map_file_option(filepath)
+      case filepath
+      when 'STDOUT' then $stdout
+      when 'STDERR' then $stderr
+      when 'STDIN' then $stdin
+      when 'STRING' then StringIO.new
+      else File.expand_path(filepath)
+      end
+    end
+
+    def map_file_option(filepath)
+      ::Rzo::Logging.map_file_option(filepath)
+    end
+
+    def log
+      ::Rzo::Logging.log
+    end
+
+    ##
+    # Reset the logging system, requires command line options to have been
+    # parsed.
+    #
+    # @param [Hash<Symbol, String>] opts Options hash, passed to the support module
+    def reset_logging!(opts)
+      ::Rzo::Logging.reset_logging!(opts)
+    end
+
+    ##
+    # Logs a message at the fatal (syslog err) log level
+    def fatal(msg)
+      log.fatal msg
+    end
+
+    ##
+    # Logs a message at the error (syslog warning) log level.
+    # i.e. May indicate that an error will occur if action is not taken.
+    # e.g. A non-root file system has only 2GB remaining.
+    def error(msg)
+      log.error msg
+    end
+
+    ##
+    # Logs a message at the warn (syslog notice) log level.
+    # e.g. Events that are unusual, but not error conditions.
+    def warn(msg)
+      log.warn msg
+    end
+
+    ##
+    # Logs a message at the info (syslog info) log level
+    # i.e. Normal operational messages that require no action.
+    # e.g. An application has started, paused or ended successfully.
+    def info(msg)
+      log.info msg
+    end
+
+    ##
+    # Logs a message at the debug (syslog debug) log level
+    # i.e.  Information useful to developers for debugging the application.
+    def debug(msg)
+      log.debug msg
+    end
+
+    ##
+    # Helper method to write output, used for stubbing out the tests.
+    #
+    # @param [String, IO] output the output path or a IO stream
+    def write_output(str, output)
+      if output.is_a?(IO)
+        output.puts(str)
+      else
+        File.open(output, 'w+') { |f| f.puts(str) }
+      end
+    end
+
+    ##
+    # Helper method to read from STDIN, or a file and execute an arbitrary block
+    # of code.  A block must be passed which will recieve an IO object in the
+    # event input is a readable file path.
+    def input_stream(input)
+      if input.is_a?(IO)
+        yield input
+      else
+        File.open(input, 'r') { |stream| yield stream }
+      end
+    end
+
+    ##
+    # Alternative to puts, writes output to STDERR by default and logs at level
+    # info.
+    def say(msg)
+      log.info(msg)
+      @stderr.puts(msg)
+    end
+  end
+end