rconf 0.5.0

data/lib/rconf/configurator_registry.rb

@@ -0,0 +1,63 @@
+# Copyright (C) 2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET. Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited. Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee
+
+module RightConf
+
+  # Configurator mixin, defines DSL and common validation method
+  class ConfiguratorRegistry
+
+    include Singleton
+
+    # Associate configurator with given key
+    #
+    # === Parameters
+    # key(Symbol):: Key configurator should be associated with
+    # value(Class):: Associated configurator class
+    #
+    # === Return
+    # value(Class):: Configurator class
+    def []=(key, value)
+      @configurators[key] = value
+    end
+
+    # Configurator class for given key
+    #
+    # === Parameters
+    # key(String):: Configurator for given key
+    #
+    # === Return
+    # cfg_class(Constant):: Configurator class if there is one
+    # nil:: Otherwise
+    def [](key)
+      @configurators[key]
+    end
+
+    # Iterate through all configurators
+    #
+    # === Block
+    # Block should take one argument which is the configurator being iterated on
+    #
+    # === Return
+    # true:: Always return true
+    def each(&blk)
+      @configurators.each(&blk)
+      true
+    end
+
+    protected
+
+    # Initialize configurators hash
+    def initialize
+      @configurators = Hash.new
+    end
+
+  end
+end

data/lib/rconf/configurators/bundler_configurator.rb

@@ -0,0 +1,85 @@
+# Copyright (C) 2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET. Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited. Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee
+
+module RightConf
+
+  class BundlerConfigurator
+
+    DEFAULT_GEM_PATH = 'vendor/system_gems/cache'
+
+    include Configurator
+
+    register :bundler
+
+    description 'Installs bundler and runs "bundle install"'
+
+    settings :bundler_version  => 'Version of bundler gem, e.g. "1.0.10"',
+             :bundler_gem_path => 'Path to bundler gem, e.g. "vendor/system_gems/cache"' 
+             
+    validate_has_settings :bundler_version
+
+    # Install bundler if needed and run bundle install
+    #
+    # === Return
+    # true:: Always return true
+    def run_linux
+      report_check("Checking for bundler #{bundler_version}")
+      res = Command.execute('bundle', '--version')
+      success = (res.output =~ /#{bundler_version}/)
+      report_result(success)
+      install_bundler(res.success?) unless success
+      report_check('Installing gems')
+      res = Command.execute('bundle', 'install', :abort_on_failure => 'Failed to install gems')
+      report_success
+      true
+    end
+    alias :run_darwin :run_linux
+
+    # Not implemented on windows (no bundler gem there)
+    #
+    # === Raise
+    # (Exception):: Always raise
+    def run_windows
+      raise "Bundler is not supported on Windows!"
+    end
+
+    protected
+
+    # Install bundler from gem in cache
+    #
+    # === Parameters
+    # exists(FalseClass|TrueClass):: Whether bundler is already installed
+    #                                (but is the wrong version)
+    #
+    # === Return
+    # true:: Always return true
+    #
+    # === Raise
+    # (Exception):: If bundler gem cannot be found or installed
+    def install_bundler(exists)
+      if exists
+        report_check('Uninstalling existing versions of bundler')
+        res = Command.execute('gem', 'uninstall', 'bundler', '-a', '-x', 
+                              :abort_on_failure => 'Failed to uninstall bundler')
+        report_success
+      end
+      report_check("Installing bundler #{bundler_version}")
+      bundler_gem_path DEFAULT_GEM_PATH unless bundler_gem_path
+      bundler_file = File.join(bundler_gem_path, "bundler-#{bundler_version}.gem")
+      report_fatal("Missing bundler gem at #{bundler_file}") unless File.exist?(bundler_file)
+      res = Command.execute('gem','install',  bundler_file, '--no-ri', '--no-rdoc',
+                           :abort_on_failure => 'Failed to install bundler')
+      report_success
+      true
+    end
+
+  end
+end

data/lib/rconf/configurators/ruby_configurator.rb

@@ -0,0 +1,151 @@
+# Copyright (C) 2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET. Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited. Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee
+
+module RightConf
+
+  class RubyConfigurator
+
+    # RVM version used to install rubies
+    RVM_VERSION = '1.2.6'
+
+    include Configurator
+
+    register :ruby
+
+    description "Installs ruby interpreter and rubygems.\n" +
+                'Installs and uses rvm on supported (i.e. non-Windows) platforms'
+
+    settings :ruby_version     => 'Ruby version using rvm notation (see "rvm list known")',
+             :rubygems_version => 'Rubygems version, e.g. "1.3.7"',
+             :gemset           => 'Gemset to be used for platforms supporting rvm'
+
+    validate_has_settings :ruby_version, :rubygems_version
+
+    # Switch to ruby version defined in settings
+    # Use rvm and install it if needed
+    #
+    # === Return
+    # true:: Always return true
+    def run_linux
+      check_rvm(RVM_VERSION)
+      report_check("Checking whether #{ruby_version} is the active ruby")
+      out = Command.execute('rvm', 'list').output
+      if out =~ /^=> #{ruby_version.gsub('.', '\\.')}/
+        report_success
+      else
+        report_failure
+        report_check("Switching to #{ruby_version}")
+        out = Command.execute('rvm', 'use', ruby_version).output
+        case out
+        when /is not installed\./
+          report_failure
+          report_fatal "Failed to install #{ruby}: #{@out}" if @out
+          @out = install_ruby(ruby_version)
+          run
+          return true
+        when /^Using /
+          report_success
+          check_rvmrc
+          post_note 'Configuration required switching the active ruby, please "cd" into the project directory again to activate it'
+        else
+          report_fatal("Failed to use #{ruby_version}:\n#{out}")
+        end
+      end
+      if gemset
+        report_check("Switching to gemset #{gemset}")
+        res = Command.execute('rvm', 'gemset', 'use',  gemset,
+                             :abort_on_failure => "Failed to switch to gemset '#{gemset}'") 
+        report_success
+      end
+      Command.set_prefix("rvm #{ruby_version}@#{gemset} exec --")
+      true
+    end
+    alias :run_darwin :run_linux
+
+    # Switch to ruby version defined in settings
+    # TBD
+    #
+    # === Return
+    # true:: Always return true
+    def run_windows
+    end
+
+    protected
+
+    # Check whether the right version of RVM is installed and install it if not
+    #
+    # === Parameters
+    # version(String):: Version of RVM to be checked, e.g. '1.2.6'
+    #
+    # === Return
+    # true:: Always return true
+    def check_rvm(version)
+      report_check("Checking that rvm #{version} is installed")
+      out = Command.execute('rvm', '--version').output
+      if out =~ /rvm #{RVM_VERSION.gsub('.', '\\.')}/
+        report_success
+      else
+        report_failure
+        report_check("Installing rvm #{version}")
+        rvm_src = File.join(ENV['HOME'] || '/root', '.rvm/src')
+        FileUtils.mkdir_p(rvm_src)
+        Dir.chdir(rvm_src) do
+          res = Command.execute('curl', '-O', '-f',
+                                "http://rvm.beginrescueend.com/releases/rvm-#{version}.tar.gz",
+                                :abort_on_failure => "Failed to download rvm #{version}")
+          Command.execute('tar', 'zxf', "rvm-#{version}.tar.gz")
+        end
+        Dir.chdir(File.join(rvm_src, "rvm-#{version}")) do
+          res = Command.execute('./install', :abort_on_failure => "Failed to install rvm #{version}")
+        end
+        report_success
+      end
+      true
+    end
+
+    # Install given ruby version using rvm
+    #
+    # === Parameters
+    # ruby(String):: Ruby version compatible with rvm
+    #
+    # === Return
+    # out(String):: Installation output
+    def install_ruby(ruby)
+      report_check("Installing #{ruby} (this will take a while, please be patient)")
+      res = Command.execute('rvm', 'install', ruby)
+      report_result(res.success?)
+      res.output
+    end
+
+    # Check .rvmrc and its content
+    #
+    # === Return
+    # true:: Always return true
+    def check_rvmrc
+      report_check('Setting up .rvmrc')
+      begin
+        File.open('.rvmrc', 'w') do |f|
+          f.puts "rvm #{ruby_version}@#{gemset}"
+          f.puts "type -P rconf &>/dev/null && { rconf; }"
+          f.puts "type -P rconf &>/dev/null || { echo 'rconf not installed, skipping (see .rvmrc)'; }"
+        end
+        Command.execute('rvm', 'trust', 'rvmrc')
+        report_success
+      rescue Exception => e
+        report_failure
+        report_error(e.message)
+      end
+      true
+    end
+
+  end
+end
+                       

data/lib/rconf/language.rb

@@ -0,0 +1,91 @@
+# Copyright (C) 2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET. Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited. Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee
+
+module RightConf
+
+  # DSL implementation
+  class Language
+
+    # List of configurators resulting from parsing a configuration
+    attr_reader :configurators
+
+    # Errors generated by configurators validations if any
+    attr_reader :validation_errors
+
+    # Load given file and run content to retrieve configurators
+    #
+    # === Parameters
+    # file(String):: Path to file being loaded
+    #
+    # === Result
+    # lang(Language):: Instance initialized from file
+    def self.load(file)
+      begin
+        content = IO.read(file)
+      rescue Exception => e
+        raise "Failed to load '#{file}': #{e.message}"
+      end
+      parse(content)
+    end
+
+    # Parse given configuration text
+    #
+    # === Parameters
+    # content(String):: Content to be parsed
+    #
+    # === Result
+    # lang(Language):: Instance initialized from content
+    def self.parse(content)
+      lang = new
+      lang.instance_eval(content)
+      lang
+    end
+
+    protected
+
+    # Initialize configurators and validation errors lists
+    # Do not call directly, instead call 'load'
+    def initialize
+      @configurators = Array.new
+      @validation_errors = Array.new
+    end
+
+    # Each missing method should correspond to a configurator section.
+    # Such sections consist of a block which gets eval'ed in the contect of the
+    # corresponding configurator instance.
+    #
+    # === Parameters
+    # meth(Symbol):: Method symbol, should be a configurator
+    # args(Array):: List of arguments
+    # blk(Proc):: Block to be evaled in configurator context
+    #
+    # === Return
+    # true:: Always return true
+    def method_missing(meth, *args, &blk)
+      if blk 
+        klass = ConfiguratorRegistry[meth]
+        if klass
+          configurator = klass.new(*args)
+          configurator.instance_eval(&blk)
+          error = configurator.validate
+          @validation_errors << error if error
+          @configurators << configurator
+        else
+          @validation_errors << "Unknown configurator '#{meth}'"
+        end
+      else
+        @validation_errors << "Invalid syntax, expecting block after '#{meth}'"
+      end
+      true
+    end
+
+  end
+end

data/lib/rconf/platform.rb

@@ -0,0 +1,114 @@
+# Copyright (C) 2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET. Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited. Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee
+
+require 'rbconfig'
+
+module RightConf
+
+  class Platform
+
+    include Singleton
+
+
+    # Generic platform family
+    #
+    # === Return
+    # family(Symbol):: One of :linux, :windows or :darwin
+    def family
+      @family ||= case RbConfig::CONFIG['host_os']
+                  when /mswin|win32|dos|mingw|cygwin/i then :windows
+                  when /darwin/i then :darwin
+                  when /linux/i then :linux
+                  end
+    end
+
+    # Is current platform linux?
+    #
+    # === Return
+    # true:: If current platform is linux
+    # false:: Otherwise
+    def linux?
+      return family == :linux
+    end
+
+    # Is current platform darwin?
+    #
+    # === Return
+    # true:: If current platform is darwin
+    # false:: Otherwise
+    def darwin?
+      return family == :darwin
+    end
+    # Is current platform windows?
+    #
+    # === Return
+    # true:: If current platform is Windows
+    # false:: Otherwise
+    def windows?
+      return family == :windows
+    end
+
+    # Call platform specific implementation of method whose symbol is returned
+    # by the passed in block. Arguments are passed through.
+    # e.g.
+    #
+    #   Platform.dispatch(2) { :echo }
+    #
+    # will result in 'echo_linux(2)' being executed in self if running on linux,
+    # 'echo_windows(2)' if running on Windows and 'echo_darwin(2)' if on 
+    # Mac OS X. Note that the method is run in the instance of the caller.
+    #
+    # === Parameters
+    # args:: Pass-through arguments
+    #
+    # === Block
+    # Given block should not take any argument and return a symbol for the 
+    # method that should be called
+    #
+    # === Return
+    # res(ObjecT):: Result returned by platform specific implementation
+    def dispatch(*args, &blk)
+      raise "Platform.dispatch requires a block" unless blk
+      binding = blk.binding.eval('self')
+      meth = blk.call
+      target = dispatch_candidates(meth).detect do |candidate|
+        binding.respond_to?(candidate)
+      end
+      raise "No platform dispatch target found in #{binding.class} for " + 
+            "'#{meth.inspect}', tried " + dispatch_candidates(meth).join(', ') unless target
+      binding.__send__(target, *args)
+    end
+
+    protected
+
+    # Load platform specific implementation
+    def initialize
+      require File.expand_path(File.join(File.dirname(__FILE__), 'platforms', family.to_s))
+      init
+    end
+
+    # Candidate platform specific methods for given prefix
+    # Ordered by most platform specific to most generic
+    #
+    # === Parameters
+    # prefix(String):: Method prefix
+    #
+    # === Return
+    # candidates(Array):: List of potential candidates
+    def dispatch_candidates(prefix)
+      candidates = ["#{prefix}_#{family}_#{flavor}_#{release}",
+                    "#{prefix}_#{family}_#{flavor}",
+                    "#{prefix}_#{family}"]
+      candidates.map(&:to_sym)
+    end
+
+  end
+end