kafo 0.2.2 → 0.3.0

data/lib/kafo/puppet_command.rb

@@ -1,45 +1,43 @@
 # encoding: UTF-8
-class PuppetCommand
-  def initialize(command, options = [])
-    @command = command
-    
-     # Expand the modules_path to work around the fact that Puppet doesn't
-     # allow modulepath to contain relative (i.e ..) directory references as
-     # of 2.7.23.
-     @options = options.push("--modulepath #{File.expand_path(modules_path)}")
-     @logger  = KafoConfigure.logger
-  end
+module Kafo
+  class PuppetCommand
+    def initialize(command, options = [])
+      @command = command
+      @options = options.push("--modulepath #{modules_path}")
+      @logger  = KafoConfigure.logger
+    end
 
-  def custom_answer_file
-    KafoConfigure.temp_config_file.nil? ? '' : "$kafo_answer_file=\"#{KafoConfigure.temp_config_file}\""
-  end
+    def custom_answer_file
+      KafoConfigure.temp_config_file.nil? ? '' : "$kafo_answer_file=\"#{KafoConfigure.temp_config_file}\""
+    end
 
-  def add_progress
-    KafoConfigure.verbose ? '' : "$kafo_add_progress=true"
-  end
+    def add_progress
+      KafoConfigure.verbose ? '' : "$kafo_add_progress=true"
+    end
 
-  def command
-    result = [
-        "echo '$kafo_config_file=\"#{KafoConfigure.config_file}\" #{custom_answer_file} #{add_progress} #{@command}'",
-        '|',
-        "RUBYLIB=#{["#{KafoConfigure.gem_root}/modules", ENV['RUBYLIB']].join(File::PATH_SEPARATOR)}",
-        "puppet apply #{@options.join(' ')} #{@suffix}",
-    ].join(' ')
-    @logger.debug result
-    result
-  end
+    def command
+      result = [
+          "echo '$kafo_config_file=\"#{KafoConfigure.config_file}\" #{custom_answer_file} #{add_progress} #{@command}'",
+          '|',
+          "RUBYLIB=#{["#{KafoConfigure.gem_root}/modules", ENV['RUBYLIB']].join(File::PATH_SEPARATOR)}",
+          "puppet apply #{@options.join(' ')} #{@suffix}",
+      ].join(' ')
+      @logger.debug result
+      result
+    end
 
-  def append(suffix)
-    @suffix = suffix
-    self
-  end
+    def append(suffix)
+      @suffix = suffix
+      self
+    end
 
-  private
+    private
 
-  def modules_path
-    [
-        KafoConfigure.modules_dir,
-        KafoConfigure.kafo_modules_dir,
-    ].join(':')
+    def modules_path
+      [
+          KafoConfigure.modules_dir,
+          KafoConfigure.kafo_modules_dir,
+      ].join(':')
+    end
   end
 end

data/lib/kafo/puppet_module.rb

@@ -4,90 +4,114 @@ require 'kafo/param_builder'
 require 'kafo/puppet_module_parser'
 require 'kafo/validator'
 
-class PuppetModule
-  attr_reader :name, :params, :dir_name, :class_name, :manifest_name, :manifest_path
-
-  def initialize(name, parser = PuppetModuleParser)
-    @name          = name
-    @dir_name      = get_dir_name
-    @manifest_name = get_manifest_name
-    @class_name    = get_class_name
-    @params        = []
-    @manifest_path = File.join(KafoConfigure.root_dir, '/modules/', module_manifest_path)
-    @parser        = parser
-    @validations   = []
-    @logger        = KafoConfigure.logger
-  end
+module Kafo
+  class PuppetModule
+    PRIMARY_GROUP_NAME = 'Parameters'
+
+    attr_reader :name, :params, :dir_name, :class_name, :manifest_name, :manifest_path,
+                :groups
+
+    def initialize(name, parser = PuppetModuleParser)
+      @name          = name
+      @dir_name      = get_dir_name
+      @manifest_name = get_manifest_name
+      @class_name    = get_class_name
+      @params        = []
+      @manifest_path = File.join(KafoConfigure.root_dir, '/modules/', module_manifest_path)
+      @parser        = parser
+      @validations   = []
+      @logger        = KafoConfigure.logger
+      @groups        = {}
+    end
 
-  def enabled?
-    @enabled.nil? ? @enabled = KafoConfigure.config.module_enabled?(self) : @enabled
-  end
+    def enabled?
+      @enabled.nil? ? @enabled = KafoConfigure.config.module_enabled?(self) : @enabled
+    end
 
-  def disable
-    @enabled = false
-  end
+    def disable
+      @enabled = false
+    end
 
-  def enable
-    @enabled = true
-  end
+    def enable
+      @enabled = true
+    end
 
-  def parse(builder_klass = ParamBuilder)
-    @params      = []
-    raw_data     = @parser.parse(manifest_path)
-    builder      = builder_klass.new(self, raw_data)
-    @validations = raw_data['validations']
+    def parse(builder_klass = ParamBuilder)
+      @params      = []
+      raw_data     = @parser.parse(manifest_path)
+      builder      = builder_klass.new(self, raw_data)
+      @validations = raw_data[:validations]
 
-    builder.validate
-    @params      = builder.build_params
+      builder.validate
+      @params = builder.build_params
+      @groups = builder.build_param_groups(@params)
 
-    self
-  rescue ConfigurationException => e
-    puts "Unable to continue because of:"
-    puts e.message
-    KafoConfigure.exit(:manifest_error)
-  end
+      self
+    rescue ConfigurationException => e
+      @logger.error "Unable to continue because of: #{e.message}"
+      KafoConfigure.exit(:manifest_error)
+    end
+
+    def primary_parameter_group
+      @groups.detect { |g| g.formatted_name == PRIMARY_GROUP_NAME } || dummy_primary_group
+    end
 
-  def validations(param = nil)
-    if param.nil?
-      @validations
-    else
-      @validations.select do |validation|
-        validation.arguments.map(&:to_s).include?("$#{param.name}")
+    def other_parameter_groups
+      @groups.select { |g| g.formatted_name != PRIMARY_GROUP_NAME }
+    end
+
+    def validations(param = nil)
+      if param.nil?
+        @validations
+      else
+        @validations.select do |validation|
+          validation.arguments.map(&:to_s).include?("$#{param.name}")
+        end
       end
     end
-  end
 
-  def params_hash
-    Hash[params.map { |param| [param.name, param.value] }]
-  end
+    def params_hash
+      Hash[params.map { |param| [param.name, param.value] }]
+    end
 
-  def <=> o
-    self.name <=> o.name
-  end
+    def <=> o
+      self.name <=> o.name
+    end
 
-  private
+    private
 
-  # mapping from configuration with stringified keys
-  def mapping
-    @mapping ||= Hash[KafoConfigure.config.app[:mapping].map { |k, v| [k.to_s, v] }]
-  end
+    # used when user haven't specified any primary group by name, we create a new group
+    # that holds all other groups as children, if we have no other groups (no children)
+    # we set all parameters that this module hold
+    def dummy_primary_group
+      group = ParamGroup.new(PRIMARY_GROUP_NAME)
+      other_parameter_groups.each { |child| group.add_child(child) }
+      @params.each { |p| group.add_param(p) } if group.children.empty?
+      group
+    end
 
-  # custom module directory name
-  def get_dir_name
-    mapping[name].nil? ? name : mapping[name][:dir_name]
-  end
+    # mapping from configuration with stringified keys
+    def mapping
+      @mapping ||= Hash[KafoConfigure.config.app[:mapping].map { |k, v| [k.to_s, v] }]
+    end
 
-  # custom manifest filename without .pp extension
-  def get_manifest_name
-    mapping[name].nil? ? 'init' : mapping[name][:manifest_name]
-  end
+    # custom module directory name
+    def get_dir_name
+      mapping[name].nil? ? name : mapping[name][:dir_name]
+    end
 
-  def get_class_name
-    manifest_name == 'init' ? name : "#{dir_name}::#{manifest_name}"
-  end
+    # custom manifest filename without .pp extension
+    def get_manifest_name
+      mapping[name].nil? ? 'init' : mapping[name][:manifest_name]
+    end
 
-  def module_manifest_path
-    "#{dir_name}/manifests/#{manifest_name}.pp"
-  end
+    def get_class_name
+      manifest_name == 'init' ? name : "#{dir_name}::#{manifest_name}"
+    end
+
+    def module_manifest_path
+      "#{dir_name}/manifests/#{manifest_name}.pp"
+    end
 
+  end
 end

data/lib/kafo/puppet_module_parser.rb

@@ -1,74 +1,77 @@
 # encoding: UTF-8
 require 'puppet'
-require 'rdoc'
-require 'rdoc/markup'        # required for RDoc < 0.9.5
-require 'rdoc/markup/parser' # required for RDoc < 0.9.5
+require 'kafo/doc_parser'
 
-# Based on ideas from puppet-parse by Johan van den Dorpe
-class PuppetModuleParser
-  def self.parse(file)
-    content = new(file)
+module Kafo
+  # Based on ideas from puppet-parse by Johan van den Dorpe
+  # we don't build any tree structure since e.g. params from doc does not
+  # have to be defined in puppet DSL and vice versa, we just gather all info
+  # we can read from the whole manifest
+  class PuppetModuleParser
+    def self.parse(file)
+      content = new(file)
+      docs    = content.docs
 
-    {
-        'parameters'  => content.parameters,
-        'docs'        => content.docs,
-        'validations' => content.validations
-    }
-  end
+      data              = {
+          :values      => content.values,
+          :validations => content.validations
+      }
+      data[:parameters] = data[:values].keys
+      data.merge!(docs)
+      data
+    end
 
-  def initialize(file)
-    raise ModuleName, "File not found #{file}, check you answer file" unless File.exists?(file)
-    parser = Puppet::Parser::Parser.new('production')
-    values = Puppet.settings.instance_variable_get('@values')
-    values[:production][:confdir] ||= '/' # just some stubbing
-    parser.import(file)
+    def initialize(file)
+      @file = file
+      raise ModuleName, "File not found #{file}, check you answer file" unless File.exists?(file)
+      parser                        = Puppet::Parser::Parser.new('production')
+      values                        = Puppet.settings.instance_variable_get('@values')
+      values[:production][:confdir] ||= '/' # just some stubbing
+      parser.import(@file)
 
-    # Find object in list of hostclasses
-    parser.environment.known_resource_types.hostclasses.each do |x|
-      @object = x.last if x.last.file == file
-    end
-    # Find object in list of definitions
-    parser.environment.known_resource_types.definitions.each do |x|
-      @object = x.last if x.last.file == file
+      # Find object corresponding to class defined in init.pp in list of hostclasses
+      parser.environment.known_resource_types.hostclasses.each do |ast_objects|
+        ast_type = ast_objects.last
+        @object = ast_type if ast_type.file == file
+      end
+      # Find object in list of definitions
+      parser.environment.known_resource_types.definitions.each do |ast_objects|
+        ast_type = ast_objects.last
+        @object = ast_type.last if ast_type.last.file == file
+      end
     end
-  end
 
-  # TODO - store parsed object type (Puppet::Parser::AST::Variable must be dumped later)
-  def parameters
-    parameters = {}
-    arguments  = @object.respond_to?(:arguments) ? @object.arguments : {}
-    arguments.each { |k, v| parameters[k] = v.respond_to?(:value) ? v.value : nil }
-    parameters
-  end
-
-  def klass
-    @object.name if @object.class.respond_to?(:name)
-  end
+    # TODO - store parsed object type (Puppet::Parser::AST::Variable must be dumped later)
+    def values
+      parameters = {}
+      arguments  = @object.respond_to?(:arguments) ? @object.arguments : {}
+      arguments.each { |k, v| parameters[k] = v.respond_to?(:value) ? v.value : nil }
+      parameters
+    end
 
-  def validations(param = nil)
-    @object.code.select { |stmt| stmt.is_a?(Puppet::Parser::AST::Function) && stmt.name =~ /^validate_/ }
-  end
+    def validations(param = nil)
+      @object.code.select { |stmt| stmt.is_a?(Puppet::Parser::AST::Function) && stmt.name =~ /^validate_/ }
+    end
 
-  def docs
-    docs = {}
-    if !@object.doc.nil?
-      if RDoc::Markup.respond_to?(:parse)
-        rdoc  = RDoc::Markup.parse(@object.doc)
-      else # RDoc < 3.10.0
-        rdoc = RDoc::Markup::Parser.parse(@object.doc)
-      end
-      items = rdoc.parts.select { |part| part.respond_to?(:items) }.map(&:items).flatten
-      items.each do |item|
-        # Skip rdoc items that aren't paragraphs
-        next unless (item.parts.to_s.scan("RDoc::Markup::Paragraph") == ["RDoc::Markup::Paragraph"])
-        # RDoc (>= 4) makes label an array
-        label = item.label.is_a?(Array) ? item.label.first : item.label
-        # Documentation must be a list - if there's no label then skip
-        next if label.nil?
-        key       = label.tr('^A-Za-z0-9_-', '')
-        docs[key] = item.parts.first.parts.map!(&:strip)
+    # returns data in following form
+    # {
+    #   :docs => { $param1 => 'documentation without types and conditions'}
+    #   :types => { $param1 => 'boolean'},
+    #   :groups => { $param1 => ['Parameters', 'Advanced']},
+    #   :conditions => { $param1 => '$db_type == "mysql"'},
+    # }
+    def docs
+      data = { :docs => {}, :types => {}, :groups => {}, :conditions => {} }
+      if @object.nil?
+        raise DocParseError, "no documentation found for manifest #{@file}, parsing error?"
+      elsif !@object.doc.nil?
+        parser            = DocParser.new(@object.doc).parse
+        data[:docs]       = parser.docs
+        data[:groups]     = parser.groups
+        data[:types]      = parser.types
+        data[:conditions] = parser.conditions
       end
+      data
     end
-    docs
   end
 end

data/lib/kafo/string_helper.rb

@@ -1,21 +1,25 @@
 # encoding: UTF-8
-module StringHelper
-  def dashize(string)
-    string.tr('_', '-')
-  end
-  alias :d :dashize
+module Kafo
+  module StringHelper
+    def dashize(string)
+      string.tr('_', '-')
+    end
 
-  def underscore(string)
-    string.tr('-', '_')
-  end
-  alias :u :underscore
+    alias :d :dashize
 
-  def with_prefix(param)
-    prefix = KafoConfigure.config.app[:no_prefix] ? '' : "#{d(param.module_name)}-"
-    "#{prefix}#{d(param.name)}"
-  end
+    def underscore(string)
+      string.tr('-', '_')
+    end
+
+    alias :u :underscore
+
+    def with_prefix(param)
+      prefix = KafoConfigure.config.app[:no_prefix] ? '' : "#{d(param.module_name)}-"
+      "#{prefix}#{d(param.name)}"
+    end
 
-  def parametrize(param)
-    "--#{with_prefix(param)}"
+    def parametrize(param)
+      "--#{with_prefix(param)}"
+    end
   end
 end

data/lib/kafo/system_checker.rb

@@ -1,26 +1,28 @@
 # encoding: UTF-8
 
-class SystemChecker
-  def self.check
-    new(File.join(KafoConfigure.root_dir, 'checks', '*')).check
-  end
-
-  def initialize(path)
-    @checkers = Dir.glob(path)
-  end
+module Kafo
+  class SystemChecker
+    def self.check
+      new(File.join(KafoConfigure.root_dir, 'checks', '*')).check
+    end
 
-  def logger
-    Logging::logger['checks']
-  end
+    def initialize(path)
+      @checkers = Dir.glob(path)
+    end
 
-  def check
-    @checkers.map! do |checker|
-      logger.debug "Executing checker: #{checker}"
-      stdout = `#{checker}`
-      logger.error stdout unless stdout.empty?
-      $?.exitstatus == 0
+    def logger
+      Logging::logger['checks']
     end
 
-    @checkers.all?
+    def check
+      @checkers.map! do |checker|
+        logger.debug "Executing checker: #{checker}"
+        stdout = `#{checker}`
+        logger.error stdout unless stdout.empty?
+        $?.exitstatus == 0
+      end
+
+      @checkers.all?
+    end
   end
 end