boxgrinder-build 0.4.1 → 0.5.0

data/lib/boxgrinder-build/helpers/plugin-helper.rb

@@ -18,22 +18,22 @@
 # Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 # 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
-require 'boxgrinder-build/managers/operating-system-plugin-manager'
-require 'boxgrinder-build/managers/platform-plugin-manager'
-require 'boxgrinder-build/managers/delivery-plugin-manager'
+require 'boxgrinder-build/managers/plugin-manager'
+require 'rubygems'
 
 module BoxGrinder
   class PluginHelper
     def initialize( options = {} )
-      @log = options[:log] || Logger.new(STDOUT)
+      @log      = options[:log] || Logger.new(STDOUT)
+      @options  = options[:options]
     end
 
     def load_plugins
-      Dir["#{File.dirname( __FILE__ )}/../plugins/**/*-plugin.rb"].each { |file| require "boxgrinder-build/plugins/#{file.scan(/\/plugins\/(.*)\.rb$/).to_s}" }
+      read_and_require
 
-      @os_plugins       = OperatingSystemPluginManager.instance.initialize_plugins( :log => @log ).plugins
-      @platform_plugins = PlatformPluginManager.instance.initialize_plugins( :log => @log ).plugins
-      @delivery_plugins = DeliveryPluginManager.instance.initialize_plugins( :log => @log ).plugins
+      @os_plugins       = PluginManager.instance.plugins[:os]
+      @platform_plugins = PluginManager.instance.plugins[:platform]
+      @delivery_plugins = PluginManager.instance.plugins[:delivery]
 
       print_plugins( 'os' ) { @os_plugins }
       print_plugins( 'platform' ) { @platform_plugins }
@@ -42,44 +42,44 @@ module BoxGrinder
       self
     end
 
-    def print_plugins( type )
-      @log.debug "Loading #{type} plugins..."
-
-      plugins = yield
+    def parse_plugin_list
+      plugins = []
 
-      @log.debug "We have #{plugins.size} #{type} plugin(s) registered"
-
-      plugins.each_value do |plugin|
-        @log.debug "- plugin for #{plugin.info[:full_name]}."
+      unless @options.plugins.nil?
+        plugins = @options.plugins.gsub('\'', '').gsub('"', '').split(',')
+        plugins.each { |plugin| plugin.chomp!; plugin.strip! }
       end
 
-      @log.debug "Plugins loaded."
+      plugins
     end
 
-    def deliverables_exists?( deliverables )
-      return false unless File.exists?(deliverables[:disk])
+    def read_and_require
+      plugins = %w(boxgrinder-build-fedora-os-plugin boxgrinder-build-rhel-os-plugin boxgrinder-build-centos-os-plugin boxgrinder-build-ec2-platform-plugin boxgrinder-build-vmware-platform-plugin boxgrinder-build-s3-delivery-plugin boxgrinder-build-sftp-delivery-plugin boxgrinder-build-local-delivery-plugin) + parse_plugin_list
+
+      plugins.flatten.each do |plugin|
+        @log.trace "Requiring plugin '#{plugin}'..."
 
-      [:metadata, :other].each do |deliverable_type|
-        deliverables[deliverable_type].each_value do |file|
-          return false unless File.exists?(file)
+        begin
+          gem plugin
+          require plugin
+        rescue Gem::LoadError
+          @log.warn "Specified gem: '#{plugin}' wasn't found. Make sure its name is correct, skipping..." unless plugin.match(/^boxgrinder-build-(.*)-plugin/)
         end
       end
-
-      true
     end
 
-    def deliverables_array( deliverables )
-      files = []
+    def print_plugins( type )
+      @log.debug "Loading #{type} plugins..."
+
+      plugins = yield
 
-      files << deliverables[:disk]
+      @log.debug "We have #{plugins.size} #{type} plugin(s) registered"
 
-      [:metadata, :other].each do |deliverable_type|
-        deliverables[deliverable_type].each_value do |file|
-          file << file
-        end
+      plugins.each do |plugin_name_or_type, plugin_info|
+        @log.debug "- #{plugin_name_or_type} plugin for #{plugin_info[:full_name]}."
       end
 
-      files
+      @log.debug "Plugins loaded."
     end
 
     attr_reader :os_plugins

data/lib/boxgrinder-build/managers/plugin-manager.rb

@@ -0,0 +1,98 @@
+# JBoss, Home of Professional Open Source
+# Copyright 2009, Red Hat Middleware LLC, and individual contributors
+# by the @authors tag. See the copyright.txt in the distribution for a
+# full listing of individual contributors.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'singleton'
+
+module BoxGrinder
+  module Plugins
+    def plugin( args )
+      PluginManager.instance.register_plugin( args )
+    end
+  end
+end
+
+include BoxGrinder::Plugins
+
+# TODO consider removing singleton pattern
+module BoxGrinder
+  class PluginManager
+    include Singleton
+
+    def initialize
+      @plugins = { :delivery => {}, :os => {}, :platform => {}}
+    end
+
+    def register_plugin( info )
+      validate_plugin_info( info )
+
+      raise "We already have registered plugin for #{info[:name]}." unless @plugins[info[:name]].nil?
+
+      unless info[:types].nil?
+        info[:types].each do |type|
+          @plugins[info[:type]][type] = info
+        end
+      else
+        @plugins[info[:type]][info[:name]] = info
+      end
+
+      self
+    end
+
+    def validate_plugin_info( info )
+      raise "No name specified for your plugin" if info[:name].nil?
+      raise "No class specified for your plugin" if info[:class].nil?
+      raise "No type specified for your plugin" if info[:type].nil?
+    end
+
+    def initialize_plugin( type, name )
+      plugins = @plugins[type]
+      # this should never happen
+      raise "There are no #{type} plugins." if plugins.nil?
+      plugin_info = plugins[name]
+      raise "There is no #{type} plugin registered for '#{name}' type/name." if plugin_info.nil?
+
+      begin
+        plugin = plugin_info[:class].new
+      rescue => e
+        raise "Error while initializing #{plugin_info[:class]} plugin.", e
+      end
+
+      [ plugin, plugin_info ]
+    end
+
+    def plugin_types( type )
+      types = []
+
+      available_plugins_for_selected_type = @plugins[type]
+
+      unless available_plugins_for_selected_type.nil?
+        available_plugins_for_selected_type.each_value do |info|
+          types << info[:types] unless info[:types].nil?
+          types << info[:name]
+        end
+      end
+
+      types.flatten
+    end
+
+    attr_reader :plugins
+    attr_accessor :log
+  end
+end

data/lib/boxgrinder-build/plugins/base-plugin.rb

@@ -19,7 +19,10 @@
 # 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
 require 'boxgrinder-core/helpers/exec-helper'
-require 'boxgrinder-build/helpers/plugin-helper'
+require 'boxgrinder-build/helpers/guestfs-helper'
+require 'ostruct'
+require 'openhash/openhash'
+require 'fileutils'
 require 'logger'
 
 module BoxGrinder
@@ -31,28 +34,40 @@ module BoxGrinder
 
       @log              = options[:log]           || Logger.new(STDOUT)
       @exec_helper      = options[:exec_helper]   || ExecHelper.new( :log => @log )
-      @plugin_helper    = options[:plugin_helper] || PluginHelper.new( :log => @log )
 
-      @plugin_config    = {}
-      @deliverables     = Hash.new({})
+      @plugin_info            = options[:plugin_info]
+      @previous_plugin_info   = options[:previous_plugin_info]
 
-      if self.respond_to?(:info)
-        @config_file = "#{ENV['HOME']}/.boxgrinder/plugins/#{self.info[:name]}"
+      @previous_deliverables  = options[:previous_deliverables] || {}
+      @plugin_config          = {}
 
-        read_plugin_config
+      @deliverables           = OpenHash.new
+      @target_deliverables    = OpenHash.new
+      @dir                    = OpenHash.new
 
-        @deliverables[:disk]      = nil
-        @deliverables[:platform]  = self.info[:name]
-      end
+      @dir.base               = "#{@appliance_config.path.build}/#{@plugin_info[:name]}-plugin"
+      @dir.tmp                = "#{@dir.base}/tmp"
 
-      after_init
+      @config_file            = "#{ENV['HOME']}/.boxgrinder/plugins/#{@plugin_info[:name]}"
+
+      read_plugin_config
 
       @initialized = true
 
+      after_init
+
       self
     end
 
-    attr_reader :deliverables
+    def register_deliverable( deliverable )
+      raise "You can only register deliverables after the plugin is initialized, please initialize the plugin using init method." if @initialized.nil?
+      raise "Please specify deliverables as Hash, not #{deliverable.class}." unless deliverable.is_a?(Hash)
+
+      deliverable.each do |name, path|
+        @deliverables[name]          = "#{@dir.tmp}/#{path}"
+        @target_deliverables[name]   = "#{@dir.base}/#{path}"
+      end
+    end
 
     def validate_plugin_config(fields = [], doc = nil)
       more_info = doc.nil? ? '' : "See #{doc} for more info"
@@ -60,17 +75,54 @@ module BoxGrinder
       raise "Not valid configuration file for #{info[:name]} plugin. Please create valid '#{@config_file}' file. #{more_info}" if @plugin_config.nil?
 
       fields.each do |field|
-        raise "Please specify a valid #{field} in plugin configuration file: '#{@config_file}'. #{more_info}" if @plugin_config[field].nil?
+        raise "Please specify a valid '#{field}' key in plugin configuration file: '#{@config_file}'. #{more_info}" if @plugin_config[field].nil?
       end
     end
 
     def execute(args = nil)
-      raise "Execute operation for #{self.class} plugin is not implemented"
+      raise "You can only execute the plugin after the plugin is initialized, please initialize the plugin using init method." if @initialized.nil?
+    end
+
+    def run( *args )
+      FileUtils.rm_rf @dir.tmp
+      FileUtils.mkdir_p @dir.tmp
+
+      execute( *args )
+
+      after_execute
     end
 
     def after_init
     end
 
+    def after_execute
+      @deliverables.each do |name, path|
+        @log.trace "Moving '#{path}' deliverable to target destination '#{@target_deliverables[name]}'..."
+        FileUtils.mv( path, @target_deliverables[name] )
+      end
+
+      FileUtils.rm_rf @dir.tmp
+    end
+
+    def deliverables_exists?
+      raise "You can only check deliverables after the plugin is initialized, please initialize the plugin using init method." if @initialized.nil?
+
+      exists = true
+
+      @target_deliverables.each_value do |file|
+        unless File.exists?(file)
+          exists = false
+          break
+        end
+      end
+
+      exists
+    end
+
+    def deliverables
+      @target_deliverables
+    end
+
     def set_default_config_value(key, value)
       @plugin_config[key] = @plugin_config[key].nil? ? value : @plugin_config[key]
     end
@@ -83,14 +135,15 @@ module BoxGrinder
       begin
         @plugin_config = YAML.load_file(@config_file)
       rescue
-        raise "An error occurred while reading configuration file #{@config_file} for #{self.class.name}. It is a valid YAML file?"
+        raise "An error occurred while reading configuration file #{@config_file} for #{self.class.name}. Is it a valid YAML file?"
       end
     end
 
-    def customize(disk_path)
+    # TODO consider removing this from BasePlugin and moving to another base class
+    def customize( disk_path )
       raise "Customizing cannot be started until the plugin isn't initialized" if @initialized.nil?
 
-      ApplianceCustomizeHelper.new(@config, @appliance_config, disk_path, :log => @log).customize do |guestfs, guestfs_helper|
+      GuestFSHelper.new( disk_path, :log => @log ).customize  do |guestfs, guestfs_helper|
         yield guestfs, guestfs_helper
       end
     end

data/spec/Rakefile

@@ -0,0 +1,13 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new(:default) do |t|
+  t.libs.unshift "../../boxgrinder-core/lib"
+  t.libs.unshift "../../boxgrinder-core/spec"
+
+  t.spec_files = FileList['**/*-spec.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec' ]
+  t.spec_opts = [ '--format', 's']
+end

data/spec/appliance-spec.rb

@@ -0,0 +1,195 @@
+require 'boxgrinder-build/appliance'
+require 'rspec/rspec-config-helper'
+require 'rbconfig'
+require 'ostruct'
+
+module BoxGrinder
+  describe Appliance do
+    include RSpecConfigHelper
+
+    before(:all) do
+      @arch = RbConfig::CONFIG['host_cpu']
+    end
+
+    def prepare_appliance( options = OpenStruct.new )
+      options.name      = 'boxgrinder'
+      options.version   = '1.0'
+
+      @appliance = Appliance.new( "#{File.dirname( __FILE__ )}/rspec/src/appliances/jeos-f13.appl", :log => Logger.new('/dev/null'), :options => options )
+    end
+
+    before(:each) do
+      prepare_appliance
+    end
+
+    it "should create only base image" do
+      validator = mock(ApplianceConfigValidator)
+      validator.should_receive(:validate)
+
+      ApplianceConfigValidator.should_receive(:new).with(any_args).and_return(validator)
+
+      plugin_manager_first_call = mock('PluginManagerOne')
+      plugin_manager_first_call.should_receive(:plugins).and_return({})
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_first_call)
+
+      os_plugin = mock('OS Plugin')
+      os_plugin.should_receive(:init)
+      os_plugin.should_receive(:deliverables_exists?).and_return(false)
+      os_plugin.should_receive(:run)
+      os_plugin.should_receive(:deliverables).and_return({ :disk => 'abc'})
+
+      plugin_manager_second_call = mock('PluginManagerTwo')
+      plugin_manager_second_call.should_receive(:initialize_plugin).with(:os, :fedora).and_return([ os_plugin, {:class => Appliance, :type => :os, :name => :fedora, :full_name  => "Fedora", :versions   => ["11", "12", "13", "rawhide"] } ] )
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_second_call)
+
+      @appliance.create
+    end
+
+    it "should build appliance and convert it to VMware format" do
+      prepare_appliance( OpenStruct.new({ :platform => :vmware }) )
+
+      validator = mock(ApplianceConfigValidator)
+      validator.should_receive(:validate)
+
+      ApplianceConfigValidator.should_receive(:new).with(any_args).and_return(validator)
+
+      os_plugin_output = {}
+
+      @appliance.should_receive(:execute_os_plugin).and_return(os_plugin_output)
+
+      plugin_manager_first_call = mock('PluginManagerOne')
+      plugin_manager_first_call.should_receive(:plugins).and_return({})
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_first_call)
+
+      platform_plugin = mock('VMware Plugin')
+      platform_plugin.should_receive(:init)
+      platform_plugin.should_receive(:deliverables_exists?).and_return(false)
+      platform_plugin.should_receive(:run)
+      platform_plugin.should_receive(:deliverables).and_return({ :disk => 'abc'})
+
+      plugin_manager_second_call = mock('PluginManagerTwo')
+      plugin_manager_second_call.should_receive(:initialize_plugin).with(:platform, :vmware).and_return([ platform_plugin, {:class => Appliance, :type => :platform, :name => :vmware, :full_name  => "VMware"} ] )
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_second_call)
+
+      @appliance.create
+    end
+
+    it "should build appliance, convert it to EC2 format and deliver it using S3 ami type" do
+      prepare_appliance( OpenStruct.new({ :platform => :ec2, :delivery => :ami }) )
+
+      validator = mock(ApplianceConfigValidator)
+      validator.should_receive(:validate)
+
+      ApplianceConfigValidator.should_receive(:new).with(any_args).and_return(validator)
+
+      os_plugin_output = { :abc => 'def'}
+      platform_plugin_output = { :abc => 'def'}
+
+      @appliance.should_receive(:execute_os_plugin).and_return(os_plugin_output)
+      @appliance.should_receive(:execute_platform_plugin).and_return(platform_plugin_output)
+
+      plugin_manager_first_call = mock('PluginManagerOne')
+      plugin_manager_first_call.should_receive(:plugins).and_return({})
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_first_call)
+
+      delivery_plugin = mock('S3 Plugin')
+      delivery_plugin.should_receive(:init)
+      delivery_plugin.should_receive(:run).with(:ami)
+
+      plugin_manager_second_call = mock('PluginManagerTwo')
+      plugin_manager_second_call.should_receive(:initialize_plugin).with(:delivery, :ami).and_return([ delivery_plugin, {:class => Appliance, :type => :delivery, :name => :s3, :full_name  => "Amazon Simple Storage Service (Amazon S3)", :types => [:s3, :cloudfront, :ami]} ] )
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_second_call)
+
+      @appliance.create
+    end
+    it "should build appliance, convert it to vmware format and deliver it using sftp ami type" do
+      prepare_appliance( OpenStruct.new({ :platform => :vmware, :delivery => :sftp }) )
+
+      validator = mock(ApplianceConfigValidator)
+      validator.should_receive(:validate)
+
+      ApplianceConfigValidator.should_receive(:new).with(any_args).and_return(validator)
+
+      os_plugin_output = { :abc => 'def'}
+      platform_plugin_output = { :abc => 'def'}
+
+      @appliance.should_receive(:execute_os_plugin).and_return(os_plugin_output)
+      @appliance.should_receive(:execute_platform_plugin).and_return(platform_plugin_output)
+
+      plugin_manager_first_call = mock('PluginManagerOne')
+      plugin_manager_first_call.should_receive(:plugins).and_return({})
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_first_call)
+
+      delivery_plugin = mock('S3 Plugin')
+      delivery_plugin.should_receive(:init)
+      delivery_plugin.should_receive(:run).with(no_args)
+
+      plugin_manager_second_call = mock('PluginManagerTwo')
+      plugin_manager_second_call.should_receive(:initialize_plugin).with(:delivery, :sftp).and_return([ delivery_plugin, {:class => Appliance, :type => :delivery, :name => :sftp, :full_name  => "SSH File Transfer Protocol"} ] )
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_second_call)
+
+      @appliance.create
+    end
+
+    it "should remove previous build when force is specified" do
+      prepare_appliance( OpenStruct.new( :force => true ) )
+
+      validator = mock(ApplianceConfigValidator)
+      validator.should_receive(:validate)
+
+      ApplianceConfigValidator.should_receive(:new).with(any_args).and_return(validator)
+
+      @appliance.should_receive(:execute_os_plugin).and_return(nil)
+      @appliance.should_receive(:execute_platform_plugin).and_return(nil)
+      @appliance.should_receive(:execute_delivery_plugin).and_return(nil)
+
+      FileUtils.should_receive(:rm_rf).with("build/appliances/#{@arch}/fedora/13/jeos-f13")
+
+      @appliance.create
+    end
+
+    it "should not execute plugins when deliverables exists" do
+      prepare_appliance( OpenStruct.new({ :platform => :vmware }) )
+
+      validator = mock(ApplianceConfigValidator)
+      validator.should_receive(:validate)
+
+      ApplianceConfigValidator.should_receive(:new).with(any_args).and_return(validator)
+
+      os_plugin = mock('OS Plugin')
+      os_plugin.should_receive(:init)
+      os_plugin.should_receive(:deliverables_exists?).and_return(true)
+      os_plugin.should_receive(:deliverables).and_return({ :disk => 'abc'})
+
+      plugin_manager_first_call = mock('PluginManagerOne')
+      plugin_manager_first_call.should_receive(:plugins).and_return({})
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_first_call)
+
+      plugin_manager_second_call = mock('PluginManagerTwo')
+      plugin_manager_second_call.should_receive(:initialize_plugin).with(:os, :fedora).and_return([ os_plugin, {:class => Appliance, :type => :os, :name => :fedora, :full_name  => "Fedora", :versions   => ["11", "12", "13", "rawhide"] } ] )
+
+      PluginManager.should_receive(:instance).and_return(plugin_manager_second_call)
+
+      platform_plugin = mock('Platform Plugin')
+      platform_plugin.should_receive(:init)
+      platform_plugin.should_receive(:deliverables_exists?).and_return(true)
+      platform_plugin.should_receive(:deliverables).and_return({ :disk => 'def'})
+
+      platform_plugin_manager_second_call = mock('PlatformPluginManagerOne')
+      platform_plugin_manager_second_call.should_receive(:initialize_plugin).with(:platform, :vmware).and_return([ platform_plugin, {:class => Appliance, :type => :platform, :name => :vmware, :full_name  => "VMware"} ] )
+
+      PluginManager.should_receive(:instance).and_return(platform_plugin_manager_second_call)
+
+      @appliance.create
+    end
+  end
+end

data/spec/helpers/appliance-customize-helper-spec.rb

@@ -0,0 +1,30 @@
+require 'boxgrinder-build/helpers/appliance-customize-helper'
+require 'rspec/rspec-config-helper'
+
+module BoxGrinder
+  describe ApplianceCustomizeHelper do
+    include RSpecConfigHelper
+
+    before(:each) do
+      @helper = ApplianceCustomizeHelper.new(generate_config, generate_appliance_config, 'a/disk', :log => Logger.new('/dev/null'))
+
+      @log = @helper.instance_variable_get(:@log)
+    end
+
+    it "should properly prepare guestfs for customization" do
+
+      guestfs_helper = mock('guestfs_helper')
+      guestfs = mock('guestfs')
+      guestfs_helper.should_receive(:run).and_return(guestfs_helper)
+      guestfs_helper.should_receive(:guestfs).and_return(guestfs)
+      guestfs_helper.should_receive(:clean_close)
+
+      GuestFSHelper.should_receive(:new).with('a/disk', :log =>  @log ).and_return(guestfs_helper)
+
+      @helper.customize do |gf, gf_helper|
+        gf_helper.should  == guestfs_helper
+        gf.should         == guestfs
+      end
+    end
+  end
+end