rubycut-babushka 0.10.6

data/lib/babushka/system_profile.rb

@@ -0,0 +1,210 @@
+module Babushka
+  class SystemProfile
+    include ShellHelpers
+    extend ShellHelpers
+
+    def self.for_host
+      {
+        'Linux' => LinuxSystemProfile,
+        'Darwin' => OSXSystemProfile,
+        'DragonFly' => DragonFlySystemProfile,
+        'FreeBSD' => FreeBSDSystemProfile
+      }[shell('uname -s')].try(:for_flavour)
+    end
+
+    def self.for_flavour
+      new
+    end
+
+    def version_info
+      @_version_info ||= get_version_info
+    end
+
+    def linux?; false end
+    def osx?; false end
+    def bsd?; false end
+    def pkg_helper; nil end
+    def pkg_helper_key; pkg_helper.try(:manager_key) end
+    def pkg_helper_str; pkg_helper_key.to_s.capitalize end
+    # The extension that dynamic libraries are given on this system. On linux
+    # libraries are named like 'libssl.so'; on OS X, 'libssl.bundle'.
+    def library_ext; 'so' end
+
+    def cpu_type
+      shell('uname -p').tap {|result|
+        result.replace shell('uname -m') if result[/unknown|\s/]
+        # These replacements are taken from PhusionPassenger::PlatformInfo.cpu_architectures
+        result.replace 'x86' if result[/^i.86$/]
+        result.replace 'x86_64' if result == 'amd64'
+      }
+    end
+
+    def total_memory
+      raise "#{self.class}#total_memory is unimplemented."
+    end
+
+    def description
+      [
+        (flavour_str unless flavour_str == system_str),
+        system_str,
+        version,
+        ("(#{name_str})" unless name_str.nil?)
+      ].compact.join(' ')
+    end
+
+    def name
+      (SystemDefinitions.names[system][flavour] || {})[release]
+    end
+    def name_str
+      (SystemDefinitions.descriptions[system][flavour] || {})[release]
+    end
+
+    def match_list
+      [name, flavour, pkg_helper_key, system, :all].compact
+    end
+
+    def matches? specs
+      [*specs].any? {|spec| first_nonmatch_for(spec).nil? }
+    end
+
+    def first_nonmatch_for spec
+      if spec == :all
+        nil
+      elsif SystemDefinitions.all_systems.include? spec
+        spec == system ? nil : :system
+      elsif PkgHelper.all_manager_keys.include? spec
+        spec == pkg_helper_key ? nil : :pkg_helper
+      elsif our_flavours.include? spec
+        spec == flavour ? nil : :flavour
+      elsif our_flavour_names.include? spec
+        spec == name ? nil : :name
+      else
+        :system
+      end
+    end
+
+    def differentiator_for specs
+      nonmatches = [*specs].map {|spec|
+        first_nonmatch_for spec
+      }.sort_by {|spec|
+        [:system, :flavour, :name].index spec
+      }.compact
+      send "#{nonmatches.last}_str" unless nonmatches.empty?
+    end
+
+    def our_flavours
+      SystemDefinitions.names[system].keys
+    end
+    def our_flavour_names
+      SystemDefinitions.names[system][flavour].values
+    end
+
+    def flavour_str_map
+      # Only required for names that can't be auto-capitalized,
+      # e.g. :ubuntu => 'Ubuntu' isn't required.
+      {
+        :linux => {
+          :centos => 'CentOS',
+          :redhat => 'Red Hat'
+        }
+      }
+    end
+
+  end
+
+  class OSXSystemProfile < SystemProfile
+    def osx?; true end
+    def library_ext; 'bundle' end
+    def system; :osx end
+    def system_str; 'Mac OS X' end
+    def flavour; system end
+    def flavour_str; system_str end
+    def version; version_info.val_for 'ProductVersion' end
+    def release; version.match(/^\d+\.\d+/).to_s end
+    def get_version_info; shell 'sw_vers' end
+    def pkg_helper; BrewHelper end
+    def total_memory; shell("sysctl -a").val_for("hw.memsize").to_i end
+  end
+
+  class BSDSystemProfile < SystemProfile
+    def bsd?; true end
+    def system; :bsd end
+    def system_str; 'BSD' end
+    def flavour; :unknown end
+    def flavour_str; system_str end
+    def version; shell 'uname -s' end
+    def release; shell 'uname -r' end
+    def get_version_info; shell 'uname -v' end
+  end
+
+  class DragonFlySystemProfile < BSDSystemProfile
+    def system_str; 'DragonFly' end
+    def flavour; :dragonfly end
+    def pkg_helper; BinPkgSrcHelper end
+    def total_memory; shell("sysctl -a").val_for("hw.physmem").to_i end
+  end
+
+  class FreeBSDSystemProfile < BSDSystemProfile
+    def system_str; 'FreeBSD' end
+    def flavour; :freebsd end
+    def pkg_helper; BinPortsHelper end
+    def total_memory; shell("sysctl -a").val_for("hw.realmem").to_i end
+  end
+
+  class LinuxSystemProfile < SystemProfile
+    def linux?; true end
+    def system; :linux end
+    def system_str; 'Linux' end
+    def flavour; :unknown end
+    def flavour_str; flavour_str_map[system][flavour] end
+    def version; 'unknown' end
+    def release; version end
+
+    def self.for_flavour
+      (detect_using_release_file || LinuxSystemProfile).new
+    end
+
+    private
+
+    def self.detect_using_release_file
+      {
+        'debian_version' => DebianSystemProfile,
+        'redhat-release' => RedhatSystemProfile,
+        'arch-release'   => ArchSystemProfile,
+        # 'gentoo-release' =>
+        # 'SuSE-release'   =>
+      }.selekt {|release_file, system_profile|
+        File.exists? "/etc/#{release_file}"
+      }.values.first
+    end
+  end
+
+  class DebianSystemProfile < LinuxSystemProfile
+    def flavour; flavour_str.downcase.to_sym end
+    def flavour_str; version_info.val_for 'Distributor ID' end
+    def version; version_info.val_for 'Release' end
+    def name; version_info.val_for('Codename').to_sym end
+    def get_version_info; ensure_lsb_release and shell('lsb_release -a') end
+    def ensure_lsb_release
+      which('lsb_release') or log("Babushka uses `lsb_release` to learn about debian-based systems.") {
+        AptHelper.install!('lsb-release')
+      }
+    end
+    def pkg_helper; AptHelper end
+    def total_memory; shell("free -b").val_for("Mem").scan(/^\d+\b/).first.to_i end
+  end
+
+  class RedhatSystemProfile < LinuxSystemProfile
+    def flavour; version_info[/^Red Hat/i] ? :redhat : version_info[/^\w+/].downcase.to_sym end
+    def version; version_info[/release [\d\.]+ \((\w+)\)/i, 1] || version_info[/release ([\d\.]+)/i, 1] end
+    def get_version_info; File.read '/etc/redhat-release' end
+    def pkg_helper; YumHelper end
+  end
+
+  class ArchSystemProfile < LinuxSystemProfile
+    def get_version_info; 'rolling' end
+    def pkg_helper; PacmanHelper end
+    def flavour; :arch end
+    def version; ''; end
+  end
+end

data/lib/babushka/task.rb

@@ -0,0 +1,142 @@
+module Babushka
+  class Task
+    include Singleton
+    include LogHelpers
+    include PathHelpers
+    include ShellHelpers
+
+    attr_reader :opts, :vars, :persistent_log
+    attr_accessor :reportable
+
+    def initialize
+      @vars = Vars.new
+      @opts = Base.cmdline.opts.dup
+      @running = false
+    end
+
+    def process dep_names, with_vars = {}
+      raise "A task is already running." if running?
+      @running = true
+      Base.in_thread { RunReporter.post_reports }
+      dep_names.all? {|dep_name| process_dep dep_name, with_vars }
+    ensure
+      @running = false
+    end
+
+    def process_dep dep_name, with_vars
+      Dep.find_or_suggest dep_name do |dep|
+        log_dep(dep) {
+          load_run_info_for dep, with_vars
+          dep.with(task_args_for(dep, with_vars)).process(:top_level => true).tap {|result|
+            save_run_info_for dep, result
+          }
+        }.tap {|result|
+          log "You can view #{opt(:debug) ? 'the' : 'a more detailed'} log at '#{log_path_for(dep)}'." unless result
+          RunReporter.queue dep, result, reportable
+          BugReporter.report dep if reportable
+        }
+      end
+    end
+
+    def task_info dep, result
+      {
+        :version => VERSION,
+        :run_at => Time.now,
+        :system_info => Base.host.description,
+        :dep_name => dep.name,
+        :source_uri => dep.dep_source.uri,
+        :result => result
+      }
+    end
+
+    def opt name
+      opts[name]
+    end
+
+    def running?
+      @running
+    end
+
+    def callstack
+      @callstack ||= []
+    end
+
+    def log_path_for dep
+      log_prefix / dep.contextual_name
+    end
+
+    def var_path_for dep
+      VarsPrefix.p / dep.contextual_name
+    end
+
+    private
+
+    def task_args_for dep, with_vars
+      with_vars.keys.inject({}) {|hsh,k|
+        # The string arg names are sanitized in the 'meet' cmdline handler.
+        hsh[k.to_sym] = with_vars[k]; hsh
+      }.tap {|with_args|
+        if (unexpected = with_args.keys - dep.params).any?
+          log_warn "Ignoring unexpected argument#{'s' if unexpected.length > 1} #{unexpected.map(&:to_s).map(&:inspect).to_list}, which the dep '#{dep.name}' would reject."
+          unexpected.each {|key| with_args.delete(key) }
+        end
+      }
+    end
+
+    def log_dep dep
+      log_prefix.mkdir
+      log_path_for(dep).open('w') {|f|
+        f.sync = true
+        @persistent_log = f
+        yield.tap { @persistent_log = nil }
+      }
+    end
+
+    def log_prefix
+      LogPrefix.p
+    end
+
+    def load_run_info_for dep, with_vars
+      load_var_log_for(var_path_for(dep)).each_pair {|var_name,var_data|
+        vars.saved_vars[var_name].update var_data
+      }
+      with_vars.each_pair {|var_name,var_value|
+        vars.vars[var_name].update :value => var_value
+      }
+    end
+
+    def save_run_info_for dep, result
+      save_var_log_for var_path_for(dep), {
+        :info => task_info(dep, result),
+        :vars => vars.for_save
+      }
+    end
+
+    def load_var_log_for path
+      require 'yaml'
+      unless File.exists? path
+        debug "No log to load for '#{path}'."
+      else
+        dep_log = YAML.load_file path
+        unless dep_log.is_a?(Hash) && dep_log[:vars].is_a?(Hash)
+          log_error "Ignoring corrupt var log at #{path}."
+        else
+          dep_log[:vars]
+        end
+      end || {}
+    end
+
+    def save_var_log_for var_path, data
+      cd File.dirname(var_path), :create => true do |path|
+        debug "Saving #{var_path}"
+        dump_yaml_to File.basename(var_path), data
+      end
+    end
+
+    def dump_yaml_to filename, data
+      require 'yaml'
+      File.open(filename, 'w') {|f| YAML.dump data, f }
+    end
+
+  end
+end

data/lib/babushka/vars.rb

@@ -0,0 +1,108 @@
+module Babushka
+  class Vars
+    include LogHelpers
+
+    attr_reader :vars, :saved_vars
+
+    module Helpers
+      def set(key, value) Base.task.vars.set(key, value) end
+      def merge(key, value) Base.task.vars.merge(key, value) end
+      def var(name, opts = {}) Base.task.vars.var(name, opts) end
+      def define_var(name, opts = {}) Base.task.vars.define_var(name, opts) end
+    end
+
+    def initialize
+      @vars = Hashish.hash
+      @saved_vars = Hashish.hash
+    end
+
+    def set key, value
+      vars[key.to_s][:value] = value
+    end
+    def merge key, value
+      set key, ((vars[key.to_s] || {})[:value] || {}).merge(value)
+    end
+
+    def var name, opts = {}
+      define_var name, opts
+      if vars[name.to_s].has_key? :value
+        if vars[name.to_s][:value].respond_to? :call
+          vars[name.to_s][:value].call
+        else
+          vars[name.to_s][:value]
+        end
+      elsif opts[:ask] != false
+        ask_for_var name.to_s, opts
+      else
+        default_for name
+      end
+    end
+
+    def define_var name, opts = {}
+      vars[name.to_s].update opts.slice(:default, :type, :message, :choices, :choice_descriptions)
+      vars[name.to_s][:choices] ||= vars[name.to_s][:choice_descriptions].keys unless vars[name.to_s][:choice_descriptions].nil?
+      vars[name.to_s]
+    end
+
+    def for_save
+      vars.dup.inject(saved_vars.dup) {|vars_to_save,(var,_)|
+        vars_to_save[var].update vars[var]
+        save_referenced_default_for(var, vars_to_save) if vars[var][:default].is_a?(Symbol)
+        vars_to_save
+      }.reject_r {|var,data|
+        ![String, Symbol, Hash, Numeric, TrueClass, FalseClass].include?(data.class) ||
+        var.to_s['password']
+      }
+    end
+
+    def default_for key
+      if vars[key.to_s][:default].respond_to? :call
+        # If the default is a proc, re-evaluate it every time.
+        instance_eval { vars[key.to_s][:default].call }
+
+      elsif saved_vars[key.to_s].has_key? :value
+        # Otherwise, if there's a saved value, use that.
+        saved_vars[key.to_s][:value]
+
+      # Symbol defaults are references to other vars.
+      elsif vars[key.to_s][:default].is_a? Symbol
+        # Look up the current value of the referenced var.
+        referenced_val = var vars[key.to_s][:default], :ask => false
+        # Use the corresponding saved value if there is one, otherwise use the reference.
+        (saved_vars[key.to_s][:values] ||= {})[referenced_val] || referenced_val
+
+      else
+        # Otherwise, use the default.
+        vars[key.to_s][:default]
+      end
+    end
+
+
+    private
+
+    def ask_for_var key, opts
+      set key, Prompt.send("get_#{vars[key][:type] || 'value'}",
+        message_for(key),
+        vars[key].slice(:choices, :choice_descriptions).merge(
+          opts
+        ).merge(
+          :default => default_for(key),
+          :dynamic => vars[key][:default].respond_to?(:call)
+        )
+      )
+    end
+
+    def message_for key
+      printable_key = key.to_s.gsub '_', ' '
+      vars[key][:message] || printable_key
+    end
+
+    def save_referenced_default_for var, vars_to_save
+      vars_to_save[var][:values] ||= {}
+      vars_to_save[var][:values][ # set the saved value of this var
+        vars[vars[var][:default].to_s][:value] # for this var's current default reference
+      ] = vars_to_save[var].delete(:value) # to the referenced var's value
+    end
+
+  end
+end