sunshine 1.0.0.pre

data/lib/sunshine/output.rb

@@ -0,0 +1,131 @@
+module Sunshine
+
+  ##
+  # The Output class handles all of the logging to the shell
+  # during the Sunshine runtime.
+
+  class Output
+
+    COLORS = {
+      Logger::UNKNOWN => :red,
+      Logger::FATAL   => :red,
+      Logger::ERROR   => :red,
+      Logger::WARN    => :yellow,
+      Logger::INFO    => :default,
+      Logger::DEBUG   => :cyan,
+    }
+
+    attr_accessor :logger, :indent, :level
+
+    def initialize(options={})
+      @logger = Logger.new options[:output] || $stdout
+      @logger.formatter = lambda{|sev, time, progname, msg| msg}
+      @level = @logger.level = options[:level] || Logger::DEBUG
+      @indent = 0
+    end
+
+    ##
+    # Prints messages according to the standard output format.
+    # Options supported:
+    #   :level:    level of the log message
+    #   :indent:  indentation of the message
+    def print(title, message, options={})
+      severity = options[:level] || Logger::DEBUG
+      color = COLORS[severity]
+
+      options[:indent] = 0 if options[:indent] < 0
+      indent = " " * (options[:indent].to_i * 2)
+
+      print_string = message.split("\n")
+      print_string.map!{|m| "#{indent}[#{title}] #{m.chomp}"}
+      print_string = "#{print_string.join("\n")} \n"
+      print_string = print_string.foreground(color)
+      print_string = print_string.bright if indent.empty?
+
+      @logger.add(severity, print_string)
+    end
+
+    ##
+    # Generic log message which handles log indentation (for clarity).
+    # Log indentation if achieved done by passing a block:
+    #
+    #   output.log("MAIN", "Main thing is happening") do
+    #     ...
+    #     output.log("SUB1", "Sub process thing") do
+    #       ...
+    #       output.log("SUB2", "Innermost process thing")
+    #     end
+    #   end
+    #
+    #   output.log("MAIN", "Start something else")
+    #
+    #   ------
+    #   > [MAIN] Main thing is happening
+    #   >   [SUB1] Sub process thing
+    #   >     [SUB2] Innermost process thing
+    #   >
+    #   > [MAIN] Start something else
+    #
+    # Log level is set to the instance's default unless
+    # specified in the options argument with :level => Logger::LEVEL.
+    # The default log level is Logger::INFO
+    #
+    # Best practice for using log levels is to call the level methods
+    # which all work similarly to the log method:
+    # unknown, fatal, error, warn, info, debug
+    def log(title, message, options={}, &block)
+      unless Sunshine.trace?
+        return block.call if block_given?
+        return
+      end
+
+      options = {:indent => @indent}.merge(options)
+      self.print(title, message, options)
+      if block_given?
+        @indent = @indent + 1
+        begin
+          block.call
+        ensure
+          @indent = @indent - 1 unless @indent <= 0
+          @logger << "\n"
+        end
+      end
+    end
+
+    ##
+    # Log a message of log level unknown.
+    def unknown(title, message, options={}, &block)
+      self.log(title, message, options.merge(:level => Logger::UNKNOWN), &block)
+    end
+
+    ##
+    # Log a message of log level fatal.
+    def fatal(title, message, options={}, &block)
+      self.log(title, message, options.merge(:level => Logger::FATAL), &block)
+    end
+
+    ##
+    # Log a message of log level error.
+    def error(title, message, options={}, &block)
+      self.log(title, message, options.merge(:level => Logger::ERROR), &block)
+    end
+
+    ##
+    # Log a message of log level warn.
+    def warn(title, message, options={}, &block)
+      self.log(title, message, options.merge(:level => Logger::WARN), &block)
+    end
+
+    ##
+    # Log a message of log level info.
+    def info(title, message, options={}, &block)
+      self.log(title, message, options.merge(:level => Logger::INFO), &block)
+    end
+
+    ##
+    # Log a message of log level debug.
+    def debug(title, message, options={}, &block)
+      self.log(title, message, options.merge(:level => Logger::DEBUG), &block)
+    end
+  end
+end

data/lib/sunshine/package_managers/apt.rb

@@ -0,0 +1,48 @@
+module Sunshine
+
+  ##
+  # The Apt dependency class supports basic apt-get features:
+  #
+  #   dependency_lib.instance_eval do
+  #     apt "ruby", :version => '1.9'
+  #   end
+  #
+  # See the Dependency class for more info.
+
+  class Apt < Dependency
+
+    def initialize(name, options={}, &block)
+      super(name, options) do
+        pkg_name = build_pkg_name @pkg.dup, options
+
+        install    "apt-get install -y #{pkg_name}"
+        uninstall  "apt-get remove -y #{pkg_name}"
+
+        @pkg = "#{@pkg}-#{options[:version]}" if options[:version]
+        check_test "apt-cache search ^#{@pkg} | grep -c ^#{@pkg}", '-ge 1'
+
+        instance_eval(&block) if block_given?
+      end
+    end
+
+
+    private
+
+    def build_pkg_name pkg_name, options={}
+      pkg_name << "=#{options[:version]}" if options[:version]
+
+      pkg_name
+    end
+
+
+    def run_command(command, options={})
+      if @dependency_lib
+        if @dependency_lib.exist?('apt')
+          @dependency_lib.install 'apt', options
+        end
+      end
+
+      super
+    end
+  end
+end

data/lib/sunshine/package_managers/dependency.rb

@@ -0,0 +1,349 @@
+module Sunshine
+
+  ##
+  # Dependency objects let you define how to install, check, and remove
+  # a described package, including parent dependency lookup and installation.
+  #
+  #   Dependency.new "ruby", :tree => dependency_lib do
+  #     install    "sudo yum install ruby"
+  #     uninstall  "sudo yum remove ruby"
+  #     check_test "yum list installed ruby | grep -c ruby", "-ge 1"
+  #   end
+  #
+  # Dependencies are more commonly defined through a Settler class'
+  # constructor methods:
+  #
+  #   dependency_lib.instance_eval do
+  #     dependency 'custom' do
+  #       requires  'yum', 'ruby'
+  #       install   'sudo yum install custom'
+  #       uninstall 'sudo yum remove custom'
+  #       check     'yum list installed custom'
+  #     end
+  #   end
+  #
+  # The Dependency class is simple to inherit and use as a built-in part of
+  # Settler (see the Yum implementation for more info):
+  #
+  #   class Yum < Dependency
+  #     def initialize(name, options={}, &block)
+  #       super(dep_lib, name, options) do
+  #         # Define install, check, and uninstall scripts specific to yum
+  #       end
+  #     end
+  #     ...
+  #   end
+  #
+  # Once a subclass is defined a constructor method is added automatically
+  # to the Settler class:
+  #
+  #   dependency_lib.instance_eval do
+  #     yum "ruby", :version => '1.9'
+  #   end
+
+  class Dependency
+
+    class CmdError < Exception; end
+    class InstallError < Exception; end
+    class UninstallError < Exception; end
+
+
+    ##
+    # Check if sudo should be used
+
+    def self.sudo
+      @sudo ||= nil
+    end
+
+
+    ##
+    # Assign a sudo value. A value of nil means 'don't assign sudo',
+    # true means sudo, string means sudo -u, false means, explicitely
+    # don't use sudo. Yum and Gem dependency types default to sudo=true.
+
+    def self.sudo= value
+      @sudo = value
+    end
+
+
+    attr_reader :name, :pkg, :parents, :children
+
+    def initialize name, options={}, &block
+      @dependency_lib = options[:tree]
+
+      @name    = name.to_s
+      @pkg     = options[:pkg] || @name
+      @options = options.dup
+
+      @install   = nil
+      @uninstall = nil
+      @check     = nil
+
+      @parents  = []
+      @children = []
+
+      @shell = Sunshine.shell
+
+      requires(*options[:requires]) if options[:requires]
+
+      instance_eval(&block) if block_given?
+    end
+
+
+    ##
+    # Append a child dependency
+
+    def add_child name
+      @children << name
+    end
+
+
+    ##
+    # Get direct child dependencies
+
+    def child_dependencies
+      @children
+    end
+
+
+    ##
+    # Define the command that checks if the dependency is installed.
+    # The check command must have an appropriate exitcode:
+    #
+    #   dep.check "test -s 'yum list installed depname'"
+
+    def check cmd_str=nil, &block
+      @check = cmd_str || block
+    end
+
+
+    ##
+    # Define checking that the dependency is installed via unix's 'test':
+    #
+    #   dep.check_test "yum list installed depname | grep -c depname", "-ge 1"
+
+    def check_test cmd_str, condition_str
+      check "test \"$(#{cmd_str})\" #{condition_str}"
+    end
+
+
+    ##
+    # Define the install command for the dependency:
+    #
+    #   dep.install "yum install depname"
+
+    def install cmd=nil, &block
+      @install = cmd || block
+    end
+
+
+    ##
+    # Run the install command for the dependency
+    # Allows options:
+    # :call:: obj - an object that responds to call will be passed the bash cmd
+    # :skip_parents:: true - install regardless of missing parent dependencies
+    #
+    #   runner = lambda{|str| system(str)}
+    #   dep.install! :call => runner
+
+    def install! options={}
+      return if installed?(options)
+
+      if options[:skip_parents]
+        missing = missing_parents?
+        if missing
+          raise(InstallError, "Could not install #{@name}. "+
+            "Missing dependencies #{missing.join(", ")}")
+        end
+      else
+        install_parents!(options)
+      end
+
+      run_command(@install, options)
+      raise(InstallError, "Failed installing #{@name}") unless
+        installed?(options)
+    end
+
+
+    ##
+    # Call install on direct parent dependencies
+    # Allows options:
+    # :call:: obj - an object that responds to call will be passed the bash cmd
+    #
+    #   runner = lambda{|str| system(str)}
+    #   dep.install_parents! :call => runner
+
+    def install_parents! options={}
+      return unless @dependency_lib
+
+      @parents.each do |dep|
+        @dependency_lib.get(dep, options).install!(options)
+      end
+    end
+
+
+    ##
+    # Run the check command to verify that the dependency is installed
+    # Allows options:
+    # :call:: obj - an object that responds to call will be passed the bash cmd
+    #
+    #   runner = lambda{|str| system(str)}
+    #   dep.installed? :call => runner
+
+    def installed? options={}
+      run_command @check, options
+    rescue => e
+      false
+    end
+
+
+    ##
+    # Checks if any parents dependencies are missing
+    # Allows options:
+    # :call:: obj - an object that responds to call will be passed the bash cmd
+    #
+    #   runner = lambda{|str| system(str)}
+    #   dep.missing_parents? :call => runner
+
+
+    def missing_parents? options={}
+      return unless @dependency_lib
+
+      missing = []
+      @parents.each do |dep|
+        parent_dep = @dependency_lib.get dep, options
+
+        missing << dep unless parent_dep.installed?(options)
+
+        return missing if options[:limit] && options[:limit] == missing.length
+      end
+
+      missing.empty? ? nil : missing
+    end
+
+
+    ##
+    # Get direct parent dependencies
+
+    def parent_dependencies
+      @parents
+    end
+
+
+    ##
+    # Define which dependencies this dependency relies on:
+    #
+    #  dep.requires 'rubygems', 'rdoc'
+
+    def requires *deps
+      return unless @dependency_lib
+
+      @parents.concat(deps).uniq!
+      deps.each do |dep|
+        @dependency_lib.dependencies[dep].each{|d| d.add_child(@name) }
+      end
+    end
+
+
+    ##
+    # Define the uninstall command for the dependency:
+    #
+    #   dep.uninstall "yum remove depname"
+
+    def uninstall cmd=nil, &block
+      @uninstall = cmd || block
+    end
+
+
+    ##
+    # Run the uninstall command for the dependency
+    # Allows options:
+    # :call:: obj - an object that responds to call will be passed the bash cmd
+    # :force:: true - uninstalls regardless of child dependencies
+    # :remove_children:: true - removes direct child dependencies
+    # :remove_children:: :recursive - removes children recursively
+
+    def uninstall! options={}
+      if !options[:remove_children] && !options[:force]
+        raise UninstallError, "The #{@name} has child dependencies."
+      end
+      uninstall_children!(options) if options[:remove_children]
+      run_command(@uninstall, options)
+      raise(UninstallError, "Failed removing #{@name}") if installed?(options)
+    end
+
+
+    ##
+    # Removes child dependencies
+    # Allows options:
+    # :call:: obj - an object that responds to call will be passed the bash cmd
+    # :force:: true - uninstalls regardless of child dependencies
+    # :remove_children:: true - removes direct child dependencies
+    # :remove_children:: :recursive - removes children recursively
+
+    def uninstall_children! options={}
+      return unless @dependency_lib
+
+      options = options.dup
+
+      @children.each do |dep|
+        options.delete(:remove_children) unless
+          options[:remove_children] == :recursive
+
+        @dependency_lib.get(dep, options).uninstall!(options)
+      end
+    end
+
+
+    ##
+    # Alias for name
+
+    def to_s
+      @name
+    end
+
+
+    private
+
+    def run_command command, options={}
+      shell = options[:call] || @shell
+
+      if Proc === command
+        command.call shell, self.class.sudo
+
+      else
+        shell.call command, :sudo => self.class.sudo
+      end
+    end
+
+
+    def self.short_class_name str
+      str.to_s.split(":").last
+    end
+
+
+    def self.underscore str
+      str.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+
+
+    def self.inherited(subclass)
+      class_name  = short_class_name subclass.to_s
+      method_name = underscore class_name
+
+      DependencyLib.class_eval <<-STR, __FILE__, __LINE__ + 1
+      def #{method_name}(name, options={}, &block)
+        dep = #{class_name}.new(name, options.merge(:tree => self), &block)
+        self.add dep
+        dep
+      end
+      STR
+
+      DependencyLib.dependency_types << subclass
+    end
+
+    inherited self
+
+  end
+end

data/lib/sunshine/package_managers/gem.rb

@@ -0,0 +1,54 @@
+module Sunshine
+
+  ##
+  # The Gem dependency class supports most of rubygem's installation features:
+  #
+  #   dependency_lib.instance_eval do
+  #     gem "rdoc", :version => '~>0.8',
+  #                 :source  => 'http://gemcutter.org',
+  #                 :opts    => '--use-lib blah' # Anything after --
+  #   end
+  #
+  # See the Dependency class for more info.
+
+  class Gem < Dependency
+
+    self.sudo = true
+
+
+    def initialize(name, options={}, &block)
+      super(name, options) do
+        version = options[:version] ? " --version '#{options[:version]}'" : ""
+
+        source = if options[:source]
+          " --source #{options[:source]} --source http://gemcutter.org"
+        end
+
+        install_opts = " --no-ri --no-rdoc"
+        if options[:opts]
+          install_opts = "#{install_opts} -- #{options[:opts]}"
+        end
+
+        install   "gem install #{@pkg}#{version}#{source}#{install_opts}"
+        uninstall "gem uninstall #{@pkg}#{version}"
+        check     "gem list #{@pkg} -i#{version}"
+
+        requires(*options[:require].to_a) if options[:require]
+
+        instance_eval(&block) if block_given?
+      end
+    end
+
+
+    private
+
+    def run_command(command, options={})
+      if @dependency_lib
+        @dependency_lib.install 'rubygems', options if
+          @dependency_lib.exist?('rubygems')
+      end
+
+      super
+    end
+  end
+end

data/lib/sunshine/package_managers/yum.rb

@@ -0,0 +1,62 @@
+module Sunshine
+
+  ##
+  # The Yum dependency class supports most of yum's installation features:
+  #
+  #   dependency_lib.instance_eval do
+  #     yum "ruby", :version => '1.9',
+  #                 :rel     => 'release-num',
+  #                 :arch    => 'i386',
+  #                 :epoch   => 'some-epoch'
+  #   end
+  #
+  # See the Dependency class for more info.
+
+  class Yum < Dependency
+
+    self.sudo = true
+
+
+    def initialize(name, options={}, &block)
+      super(name, options) do
+        pkg_name = build_pkg_name @pkg.dup, options
+
+        install    "yum install -y #{pkg_name}"
+        uninstall  "yum remove -y #{pkg_name}"
+        check_test "yum list installed #{pkg_name} | grep -c #{@pkg}", '-ge 1'
+
+        instance_eval(&block) if block_given?
+      end
+    end
+
+
+    private
+
+    def build_pkg_name pkg_name, options={}
+      if options[:version]
+        pkg_name << "-#{options[:version]}"
+
+        if options[:rel]
+          pkg_name << "-#{options[:rel]}"
+
+          pkg_name = "#{options[:epoch]}:#{pkg_name}" if
+            options[:arch] && options[:epoch]
+        end
+      end
+
+      pkg_name << ".#{options[:arch]}" if options[:arch]
+      pkg_name
+    end
+
+
+    def run_command(command, options={})
+      if @dependency_lib
+        if @dependency_lib.exist?('yum')
+          @dependency_lib.install 'yum', options
+        end
+      end
+
+      super
+    end
+  end
+end