cupper 0.0.1 → 0.1.0

data/lib/cupper/environment.rb

@@ -0,0 +1,177 @@
+require "pathname"
+require "cupper/cupperfile"
+require "cupper/version"
+require 'colorize'
+
+module Cupper
+  class Environment
+    # The `cwd` that this environment represents
+    attr_reader :cwd
+
+    # The persistent data directory where global data can be stored. It
+    # is up to the creator of the data in this directory to properly
+    # remove it when it is no longer needed.
+    #
+    # @return [Pathname]
+    attr_reader :data_dir
+
+    # The valid name for a Cupperfile for this environment.
+    attr_reader :cupperfile_name
+
+    # The directory to the directory where local, environment-specific
+    # data is stored.
+    attr_reader :local_data_path
+
+    # The directory where temporary files for Cupper go.
+    attr_reader :tmp_path
+
+    # The path where the plugins are stored (gems)
+    attr_reader :gems_path
+
+    def check_env(ex, root_path)
+      begin
+        raise ex if !root_path 
+      rescue ex => ex
+        puts "#{ex.message}".red
+      end
+    end
+
+    # Initializes a new environment with the given options. The options
+    # is a hash where the main available key is `cwd`, which defines where
+    # the environment represents. There are other options available but
+    # they shouldn't be used in general. If `cwd` is nil, then it defaults
+    # to the `Dir.pwd` (which is the cwd of the executing process).
+    def initialize(opts=nil)
+      opts = {
+        cwd:              nil,
+        local_data_path:  nil,
+        cupperfile_name: nil,
+      }.merge(opts || {})
+
+      # Set the default working directory to look for the cupperfile
+      opts[:cwd] ||= ENV["cupper_CWD"] if ENV.key?("cupper_CWD")
+      opts[:cwd] ||= Dir.pwd
+      opts[:cwd] = Pathname.new(opts[:cwd])
+      if !opts[:cwd].directory?
+        raise Errors::EnvironmentNonExistentCWD, cwd: opts[:cwd].to_s
+      end
+      opts[:cwd] = opts[:cwd].expand_path
+      opts[:cupperfile_name] = 'Cupperfile'
+
+      # Set the Cupperfile name up. We append "Cupperfile" and "cupperfile" so that
+      # those continue to work as well, but anything custom will take precedence.
+      opts[:cupperfile_name] ||= ENV["cupper_cupperFILE"] if \
+        ENV.key?("cupper_cupperFILE")
+      opts[:cupperfile_name] = [opts[:cupperfile_name]] if \
+        opts[:cupperfile_name] && !opts[:cupperfile_name].is_a?(Array)
+
+      # Set instance variables for all the configuration parameters.
+      @cwd              = opts[:cwd]
+      @cupperfile_name = opts[:cupperfile_name]
+
+
+      # Run checkpoint in a background thread on every environment
+      # initialization. The cache file will cause this to mostly be a no-op
+      # most of the time.
+      @checkpoint_thr = Thread.new do
+        Thread.current[:result] = nil
+
+        # If we disabled state and knowing what alerts we've seen, then
+        # disable the signature file.
+        signature_file = @data_dir.join("checkpoint_signature")
+        if ENV["cupper_CHECKPOINT_NO_STATE"].to_s != ""
+          signature_file = nil
+        end
+
+        Thread.current[:result] = Checkpoint.check(
+          product: "cupper",
+          version: VERSION,
+          signature_file: signature_file,
+          cache_file: @data_dir.join("checkpoint_cache"),
+        )
+      end
+
+    end
+
+    # Return a human-friendly string for pretty printed or inspected
+    # instances.
+    #
+    # @return [String]
+    def inspect
+      "#<#{self.class}: #{@cwd}>".encode('external')
+    end
+
+    def config_loader
+      return @config_loader if @config_loader
+
+      root_cupperfile = nil
+      if root_path
+        root_cupperfile = find_cupperfile(root_path, @cupperfile_name)
+      end
+
+      @config_loader = Config::Loader.new(
+        Config::VERSIONS, Config::VERSIONS_ORDER)
+      @config_loader.set(:root, root_cupperfile) if root_cupperfile
+      @config_loader
+    end
+
+    def environment(cupperfile, **opts)
+      path = File.expand_path(cupperfile, root_path)
+      file = File.basename(path)
+      path = File.dirname(path)
+
+      Util::SilenceWarnings.silence! do
+        Environment.new({
+          child:     true,
+          cwd:       path,
+          home_path: home_path,
+          ui_class:  ui_class,
+          cupperfile_name: file,
+        }.merge(opts))
+      end
+    end
+
+    def hook(name, opts=nil)
+      opts ||= {}
+      opts[:callable] ||= Action::Builder.new
+      opts[:runner] ||= action_runner
+      opts[:action_name] = name
+      opts[:env] = self
+      opts.delete(:runner).run(opts.delete(:callable), opts)
+    end
+
+    def root_path
+      return @root_path if defined?(@root_path)
+
+      root_finder = lambda do |path|
+        # Note: To remain compatible with Ruby 1.8, we have to use
+        # a `find` here instead of an `each`.
+        vf = find_cupperfile(path, @cupperfile_name)
+        return path if vf
+        return nil if path.root? || !File.exist?(path)
+        root_finder.call(path.parent)
+      end
+
+      @root_path = root_finder.call(cwd)
+    end
+
+    def unload
+      hook(:environment_unload)
+    end
+
+    def cupperfile
+      @cupperfile ||= cupperfile.new(config_loader, [:home, :root])
+    end
+
+    def find_cupperfile(search_path, filenames=nil)
+      filenames ||= ["cupperfile", "cupperfile"]
+      filenames.each do |cupperfile|
+        current_path = search_path.join(cupperfile)
+        return current_path if current_path.file?
+      end
+
+      nil
+    end
+
+  end
+end

data/lib/cupper/errors.rb

@@ -0,0 +1,84 @@
+require 'i18n'
+
+module Cupper
+
+  module Errors
+
+    class CupperError < StandardError
+      attr_accessor :extra_data
+
+      def self.error_key(key=nil, namespace=nil)
+        define_method(:error_key) { key }
+        error_namespace(namespace) if namespace
+      end
+
+      def self.error_message(message)
+        define_method(:error_message) { message }
+      end
+
+      def self.error_namespace(namespace)
+        define_method(:error_namespace) { namespace }
+      end
+
+      def translate_error(opts)
+        return nil if !opts[:_key]
+        I18n.t("#{opts[:_namespace]}.#{opts[:_key]}", opts)
+      end
+
+      def initialize(*args)
+        key     = args.shift if args.first.is_a?(Symbol)
+        message = args.shift if args.first.is_a?(Hash)
+        message ||= {}
+        @extra_data    = message.dup
+        message[:_key] ||= error_key
+        message[:_namespace] ||= error_namespace
+        message[:_key] = key if key
+        I18n.load_path << File.expand_path("../../../templates/locales/en.yml", __FILE__)
+
+        if message[:_key]
+          message = translate_error(message)
+        else
+          message = error_message
+        end
+
+        super(message)
+      end
+
+      # The error message for this error. This is used if no error_key
+      # is specified for a translatable error message.
+      def error_message; "No error message"; end
+
+      # The default error namespace which is used for the error key.
+      # This can be overridden here or by calling the "error_namespace"
+      # class method.
+      def error_namespace; "cupper.errors"; end
+
+      # The key for the error message. This should be set using the
+      # {error_key} method but can be overridden here if needed.
+      def error_key; nil; end
+
+      # This is the exit code that should be used when exiting from
+      # this exception.
+      #
+      # @return [Integer]
+      def status_code; 1; end
+
+      protected
+
+    end
+
+    class EnvironmentNonExistentCWD < CupperError
+      error_key(:environment_non_existent_cwd)
+    end
+
+    class NoEnvironmentError < CupperError
+      error_key(:no_env)
+    end
+
+    class LocalDataDirectoryNotAccessible < CupperError
+      error_key(:local_data_dir_not_accessible)
+    end
+
+  end
+
+end

data/lib/cupper/ohai_plugins.rb

@@ -0,0 +1,13 @@
+module Cupper
+  class OhaiPlugin
+
+    attr_reader :plugins_path
+
+    def list
+      @plugins_path = File.expand_path '../../cupper/plugins/ohai', __FILE__
+      @plugins = Dir.entries(@plugins_path).reject{ |entry| entry == '.' || entry == '..'  }
+      @plugins.each { |plugin| plugin.chomp!(".rb") }
+      @plugins.sort
+    end
+  end
+end

data/lib/cupper/platform_collector.rb

@@ -0,0 +1,40 @@
+# REVIEW: This should be review in some point in the future
+# The PlatformCollector is a module that defines all the methods used to extract
+#   the information about the platform. It is a little pointless in terms of implementation
+#   but is good to know what method should be implemented.
+
+module Cupper
+  module PlatformCollector
+    def packages
+      raise NotImplementedError
+    end
+
+    def links
+      raise NotImplementedError
+    end
+
+    def services
+      raise NotImplementedError
+    end
+
+    def users
+      raise NotImplementedError
+    end
+
+    def executes
+      raise NotImplementedError
+    end
+
+    def directory
+      raise NotImplementedError
+    end
+
+    def files
+      raise NotImplementedError
+    end
+
+    def templates
+      raise NotImplementedError
+    end
+  end
+end

data/lib/cupper/plugins/cupper/arch.rb

@@ -0,0 +1,43 @@
+require 'cupper/platform_collector'
+
+module Cupper
+  class Arch
+    include PlatformCollector
+    def packages(data_extraction)
+      packages = Array.new
+      data_extraction['pacman']['pacman'].each do |pkg|
+        packages.push(pkg)
+      end
+      packages
+    end
+
+    def files(data_extraction)
+      files = Array.new
+      data_extraction['files']['files'].each do |file|
+        files.push(file)
+      end
+      files
+    end
+
+    def services(data_extraction)
+      services = Array.new
+      data_extraction['services']['services'].each do |service|
+        services.push(service)
+      end
+    end
+
+    def users(data_extraction)
+      users = Array.new
+      data_extraction['etc']['etc']['passwd'].each do |user|
+        users.push(user)
+      end
+    end
+
+    def groups(data_extraction)
+      groups = Array.new
+      data_extraction['etc']['etc']['group'].each do |group|
+        groups.push(group)
+      end
+    end
+  end
+end

data/lib/cupper/plugins/cupper/debian.rb

@@ -0,0 +1,48 @@
+require 'cupper/platform_collector'
+
+module Cupper
+  class Debian
+    include PlatformCollector
+    def packages(data_extraction)
+      packages = Array.new
+      duplicated = Array.new
+      data_extraction['pkg_deps']['pkg_deps'].each do |dep|
+        duplicated << dep[1]
+      end
+      duplicated.flatten!.uniq!
+      data_extraction['packages']['packages'].each do |pkg|
+        packages.push(pkg) unless duplicated.include? pkg[0]
+      end
+      packages
+    end
+
+    def files(data_extraction)
+      files = Array.new
+      data_extraction['files']['files'].each do |file|
+        files.push(file)
+      end
+      files
+    end
+
+    def services(data_extraction)
+      services = Array.new
+      data_extraction['services']['services'].each do |service|
+        services.push(service)
+      end
+    end
+
+    def users(data_extraction)
+      users = Array.new
+      data_extraction['etc']['etc']['passwd'].each do |user|
+        users.push(user)
+      end
+    end
+
+    def groups(data_extraction)
+      groups = Array.new
+      data_extraction['etc']['etc']['group'].each do |group|
+        groups.push(group)
+      end
+    end
+  end
+end

data/lib/cupper/plugins/ohai/dpci.rb

@@ -0,0 +1,30 @@
+
+Ohai.plugin(:Pci) do
+  provides 'dpci'
+
+  def from_cmd(cmd)
+    so = shell_out(cmd)
+    so.stdout.lines
+  end
+
+  collect_data(:default) do
+    dpci Mash.new
+    pcis from_cmd('lspci')
+
+    r_bus_slot_num = /\d+:[0-9a-fA-F]+\.\d\s/
+    r_slot_name = /^[A-z\s]+/
+
+    pcis.each_with_index do |pci, i|
+      bus_slot_num = pci.slice! r_bus_slot_num
+      slot_name = pci.slice! r_slot_name
+      pci.slice! /^:\s/
+      device_name = pci
+
+      dpci["pci_#{i}"] = {
+        "bus_slot_num" =>  bus_slot_num,
+        "slot_name" => slot_name,
+        "device_name" => device_name
+      }
+    end
+  end
+end

data/lib/cupper/plugins/ohai/files.rb

@@ -0,0 +1,68 @@
+Ohai.plugin(:Files) do
+  provides 'files'
+  depends 'platform_family'
+
+  def from_cmd(cmd)
+    so = shell_out(cmd)
+    so.stdout.lines
+  end
+
+  def has_related_package?(file)
+    if %w{debian}.include? platform_family
+      related = shell_out("dpkg -S #{file}").stdout.chomp
+    elsif %w{arch}.include? platform_family
+      related = shell_out("pacman -Qo #{file}").stdout.chomp
+    end
+    !(related.empty?)
+  end
+
+  def related_to(file)
+    if %w{debian}.include? platform_family
+      pkg, null = shell_out("dpkg -S #{file}").stdout.chomp.split(' ', 2)
+      pkg.chomp!(':')
+    elsif %w{arch}.include? platform_family
+      pkg = shell_out("pacman -Qo #{file}").stdout.chomp.split[4]
+    end
+  end
+
+  def file_content(file)
+    shell_out("cat #{file}").stdout
+  end
+
+  def add_info(file)
+    shell_out("ls -al #{file}").stdout.split(' ',5)
+  end
+
+  def extract_files
+    subdir = true
+    cmd = 'file /etc/**'
+    result = Array.new
+    while subdir do
+      result << from_cmd(cmd)
+      cmd += '/**'
+      result.flatten!
+      subdir = false if result.last.match('cannot open')
+    end
+    result
+  end
+
+  collect_data(:linux) do
+    files Mash.new
+    extract_files.each do |file|
+      path, type = file.split(' ', 2)
+      type.chomp!
+      path.chomp!(':')
+      mode, null, owner, group, null = add_info(path)
+      rel = related_to(path) if has_related_package?(path)
+      content = file_content(path)
+      files[path] = {
+        'type' => type,
+        'mode' => mode,
+        'owner' => owner,
+        'group' => group,
+        'related' => rel,
+        'content' => content
+      }
+    end
+  end
+end