build-tool 0.1.4 → 0.2

data/lib/build-tool/command_actions.rb

@@ -0,0 +1,202 @@
+require 'ftools'
+
+module BuildTool
+
+    module ModuleActions
+
+        class Base
+
+            def initialize( command, prio, type, mod )
+                @command = command
+                @logdir = command.log_directory.join( mod.name )
+                @type = type
+                @prio = prio
+                @filename = "#{prio.to_s}_#{type.to_s}"
+                @logfile = @logdir.join( @filename )
+                @module = mod
+            end
+
+            def do
+                # Make sure the directory for this module exists
+                FileUtils.mkdir_p( @logdir ) if ! $noop
+
+                # Open the logfile and then execute the command
+                while_logging do
+                    execute
+                end
+            end
+
+            #########
+            protected
+            #########
+
+            def while_logging( level = :trace, &block )
+                # Only create a logfile if we do real work
+                if !$noop
+                    Logging.logger['root'].add_appenders(
+                        Logging.appenders.file(
+                            @filename,
+                            :filename => @logfile,
+                            :layout => Logging::Layouts::Pattern.new( :pattern => '%m\n' ),
+                            :level => level ))
+                end
+
+                begin
+                    # If there is an associated command_history entry, add a module_event entry
+                    logentry = nil
+                    state = History::ModuleLog::FINISHED_SUCCESSFUL
+                    if @command.cmd
+                        logentry = History::ModuleLog.new(
+                            :module => @module.name,
+                            :event  => @type,
+                            :logfile => @logfile)
+                        @command.cmd.add_module_log(logentry)
+                        logentry.started
+                    end
+                    logger.debug "Opening logfile #{@logfile}"
+                    yield
+                rescue Interrupt => e
+                    state = History::ModuleLog::CANCELED_BY_USER
+                    logger.error "User Interrupt!"
+                    raise e
+                rescue Exception => e
+                    state = History::ModuleLog::FINISHED_WITH_ERRORS
+                    logger.error   "#{e.class}:#{e.message}"
+                    got_exception = true
+                    raise e
+                ensure
+                    if logentry
+                        logentry.finished( state )
+                    end
+                    Logging.logger['root'].remove_appenders( @filename )
+                    logger.debug "Closing logfile #{@logfile}"
+                    logger.info("More information in #{@logfile}") if got_exception
+                end
+            end
+
+        end
+
+        class Clean < Base
+
+            def initialize( command, mod, remove_build_directory )
+                super( command, 10, :clean, mod )
+                @remove_build_directory = remove_build_directory
+            end
+
+            def execute()
+                logger.info "Cleaning"
+                @module.clean( @remove_build_directory )
+            end
+
+        end
+
+        class Clone < Base
+
+            def initialize( command, mod )
+                super( command, 20, :fetch, mod )
+            end
+
+            def execute()
+                logger.info "Fetching"
+                @module.clone
+            end
+
+        end
+
+        class Fetch < Base
+
+            def initialize( command, mod )
+                super( command, 20, :fetch, mod )
+                if !mod.vcs_required.fetching_supported?
+                    logger.info "Fetching/Rebase not supported by vcs #{mod.vcs.name}. Doing it in one step."
+                end
+            end
+
+            def execute()
+                logger.info "Fetching remote changes."
+                @module.fetch
+            end
+
+        end
+
+        class Rebase < Base
+
+            def initialize( command, mod )
+                super( command, 20, :rebase, mod )
+                if !mod.vcs_required.fetching_supported?
+                    logger.info "Fetching not supported by vcs #{mod.vcs.name}. Doing nothing."
+                    return
+                end
+            end
+
+            def execute()
+                logger.info "Rebasing"
+                @module.rebase
+            end
+
+        end
+
+        class Configure < Base
+
+            def initialize( command, mod )
+                super( command, 40, :configure, mod )
+            end
+
+            def execute()
+                logger.info "Configuring"
+                if !$noop and !@module.vcs_required.checkedout?
+                    raise ConfigurationError, "Module is not checked out. Enable updating."
+                end
+                @module.configure
+            end
+
+        end
+
+        class Reconfigure < Base
+
+            def initialize( command, mod )
+                super( command, 40, :reconfigure, mod )
+            end
+
+            def execute()
+                logger.info "Reconfiguring"
+                if !$noop and !@module.vcs_required.checkedout?
+                    raise ConfigurationError, "Module is not checked out. Enable updating."
+                end
+                @module.build_system_required.reconfigure
+            end
+
+        end
+
+        class Make < Base
+
+            def initialize( command, mod, target = nil )
+                super( command, 50, :compile, mod )
+                @target = target
+            end
+
+            def execute()
+                logger.info "Building"
+                @module.build_system_required.make( @target )
+            end
+
+        end
+
+        class Install < Base
+
+            def initialize( command, mod, fast = false )
+                super( command, 60, :install, mod )
+                @fast = fast
+            end
+
+            def execute()
+                logger.info "Installing"
+                @module.build_system_required.install( @fast )
+            end
+
+        end
+
+    end # module ModuleAction
+
+end # module BuildTool
+

data/lib/build-tool/commands.rb

@@ -1,5 +1,7 @@
 require "build-tool/singleton"
 require 'build-tool/errors'
+require 'build-tool/command_actions'
+require 'build-tool/history'
 require 'shellwords'
 require 'optparse'
 require 'delegate'
@@ -70,15 +72,26 @@ module BuildTool; module Commands;
 
         include HelpText
 
+        def <=> (other)
+            return self.name <=> other.name
+        end
+
+        # The OptionParser instance associated with this command
         attr_reader :options
+
+        # The parent command if this is a sub command
         attr_reader :parent
 
+        # The commands entry in the history db or nil
+        attr_accessor :cmd
+
         def initialize(parent = nil)
             @options = OptionParser.new
             @options.set_program_name( name )
             initialize_options
             @skip_command = false
             @parent = parent
+            @cmd = nil
         end
 
         def applicable?
@@ -204,17 +217,57 @@ module BuildTool; module Commands;
             end
             @parsing = false
 
+            # Log the command into history
+            state = BuildTool::History::CommandLog::FINISHED_SUCCESSFUL
+            rc = -1 # -1 for @skip_command
+            if log?
+                @cmd = BuildTool::History::CommandLog.new( :command => "#{self.fullname} #{args.join( ' ')}", :logdir => log_directory  )
+                @cmd.started
+            end
             if !@skip_command
                 begin
-                    return do_execute( realargs )
+                    rc = do_execute( realargs )
+                    if rc != 0
+                        state = BuildTool::History::CommandLog::FINISHED_WITH_ERRORS
+                    end
                 rescue BuildTool::Error => e
+                    state = BuildTool::History::CommandLog::FINISHED_WITH_ERRORS
                     logger.error   e.message
                     logger.verbose e.backtrace.join("\n")
+                    rc = -1
+                rescue Interrupt => e
+                    state = BuildTool::History::CommandLog::CANCELED_BY_USER
+                    raise e
+                ensure
+                    if @cmd
+                        @cmd.finished( state )
+                        @cmd = nil
+                    end
                 end
             end
 
             # Either we skipped the command or we catched an exception
-            return -1;
+            return rc;
+        end
+
+        # Return the commands full name.
+        #
+        # The full name includes the parents name (if any).
+        #
+        # @return [String] The commands full name
+        #
+        def fullname
+            if parent.fullname
+                return parent.fullname + " " + name
+            else
+                return name
+            end
+        end
+
+        # Should this command be logged?
+        #
+        def log?
+            false
         end
 
         def show_help( args = [] )
@@ -297,15 +350,18 @@ module BuildTool; module Commands;
 
         def while_logging_to( dir, fname, level, &block )
             got_exception = false
-            dirname = @log_directory
-            dirname = "#{@log_directory}/#{dir}" if dir
-            FileUtils.mkdir_p( dirname )
-            Logging.logger['root'].add_appenders(
-                Logging.appenders.file(
-                    fname,
-                    :filename => dirname + '/' + fname,
-                    :layout => Logging::Layouts::Pattern.new( :pattern => '%m\n' ),
-                    :level => level ))
+            # Only create a logfile if we do real work
+            if log?
+                dirname = log_directory.to_s
+                dirname = "#{log_directory.to_s}/#{dir}" if dir
+                FileUtils.mkdir_p( dirname )
+                Logging.logger['root'].add_appenders(
+                    Logging.appenders.file(
+                        fname,
+                        :filename => dirname + '/' + fname,
+                        :layout => Logging::Layouts::Pattern.new( :pattern => '%m\n' ),
+                        :level => level ))
+            end
 
             begin
                 yield
@@ -321,29 +377,45 @@ module BuildTool; module Commands;
             end
         end
 
-        def initialize_log_directory
+        # On demand initialization
+        def log_directory
+            return @log_directory if @log_directory
+
+            # Get the root logfile directory
             logdir = configuration.log_directory
 
-            # Ensure the base log directory exists
+            # Try to find the next log directory for today.
+            i = -1
+            begin
+                @log_directory = logdir.join( "#{Date.today.to_s}-%02d" % i+=1 )
+            end until !@log_directory.exist?
+
+            # If noop is active we are finished
+            return @log_directory if $noop
+
+            # Ensure the base log directory exists.
             if !File.exist? "#{logdir}"
                 FileUtils.mkdir_p "#{logdir}"
             end
 
-            i = -1
-
-            begin
-                @log_directory = "#{logdir}/#{Date.today.to_s}-%02d" % i+=1
-            end until !File.exist?( @log_directory )
-
-            FileUtils.mkdir_p( @log_directory )
+            # Create the latest symbolic link
+            FileUtils.mkdir_p( @log_directory.to_s )
             FileUtils.rm_f( "#{logdir}/latest" )
-            FileUtils.ln_sf( @log_directory, "#{logdir}/latest" )
+            FileUtils.ln_sf( @log_directory.to_s, "#{logdir}/latest" )
+
+            @log_directory
         end
 
+
     end # class Standard
 
     class ModuleBasedCommand < Standard
 
+        def initialize( *args )
+            @all = false
+            super( *args )
+        end
+
         def is_module_ready?( mod )
             true
         end
@@ -374,15 +446,14 @@ module BuildTool; module Commands;
                 return -1
             end
 
-            # 3. Let's go
-            initialize_log_directory
-
             rc = 0      # Our return code.
 
             while_logging_to nil, 'build-status', :info do
 
                 modules.each do |mod|
 
+                    next if !( mod.active? || @all )
+
                     begin
                         logger.info ""
                         logger.info "#### Module #{mod.name}"
@@ -407,6 +478,62 @@ module BuildTool; module Commands;
             return rc;
         end
 
+        # Call the #clean method of the module.
+        #
+        # @param [Object] mod The module to use
+        def clean( mod, *args )
+            ModuleActions::Clean.new( self, mod, *args ).do
+        end
+
+        # Call the #clone method of the module.
+        #
+        # @param [Object] mod The module to use
+        def clone( mod )
+            ModuleActions::Clone.new( self, mod ).do
+        end
+
+        # Call the #configure method of the module.
+        #
+        # @param [Object] mod The module to use
+        def configure( mod )
+            ModuleActions::Configure.new( self, mod ).do
+        end
+
+        # Call the #fetch method of the module.
+        #
+        # @param [Object] mod The module to use
+        def fetch( mod )
+            ModuleActions::Fetch.new( self, mod ).do
+        end
+
+        # Call the #install method of the module.
+        #
+        # @param [Object] mod The module to use
+        def install( mod, *args )
+            ModuleActions::Install.new( self, mod, *args ).do
+        end
+
+        # Call the #make method of the module.
+        #
+        # @param [Object] mod The module to use
+        def make( mod, *args )
+            ModuleActions::Make.new( self, mod, *args ).do
+        end
+
+        # Call the #rebase method of the module.
+        #
+        # @param [Object] mod The module to use
+        def rebase( mod )
+            ModuleActions::Rebase.new( self, mod ).do
+        end
+
+        # Call the #reconfigure method of the module.
+        #
+        # @param [Object] mod The module to use
+        def reconfigure( mod )
+            ModuleActions::Reconfigure.new( self, mod ).do
+        end
+
     end
 
 
@@ -525,7 +652,7 @@ module BuildTool; module Commands;
 
         def show_help( args = [] )
             if args.length == 0
-                @commands.each do |cmd|
+                @commands.sort.each do |cmd|
                     say "%-20s: %s" % [ cmd.name, cmd.description ]
                 end
             else
@@ -542,39 +669,52 @@ module BuildTool; module Commands;
             return 0
         end
 
-        def load_commands( path, parentmod )
-            # puts "load_commands( #{path}, #{parentmod} )"
-            # Load the commands
+        def load_commands( path, parentmod, submod = nil )
+            logger.debug "load_commands( #{path} #{parentmod.inspect} #{submod.inspect}"
+            # Load all available ruby files in path
             Dir[  "#{path}/*.rb" ].each do |mod|
-                cmdname = Pathname.new( mod ).basename( '.rb' ).to_s
-                load_command( path, parentmod, cmdname )
+                load "#{mod}"
             end
-        end
 
-        def load_command( path, parentmod, mod )
-            # puts "load_command( #{path}, #{parentmod}, #{mod} )"
-            load "#{path}/#{mod}.rb"
-            self.instance_eval %{
-                if #{parentmod}::#{mod.capitalize}.instance_of? ::Module
-                    cmd = #{parentmod}::#{mod.capitalize}.create( self )
-                else
-                    cmd = #{parentmod}::#{mod.capitalize}.new( self )
+            if !submod.nil?
+                parentmod = parentmod.const_get( submod )
+            end
+            # Now look at all constants for candidates
+            parentmod.constants.each do |objname|
+                # Get the obj
+                obj = parentmod.const_get( objname )
+                # :TODO: Better solution
+                next if [ "Standard", "ModuleBasedCommand", "Base", "SubCommands", "Shell" ].include? objname
+                next if ! obj.kind_of? Class
+
+                tmp = obj
+                while tmp.superclass
+                    if tmp == BuildTool::Commands::SubCommands
+                        cmd = obj.new( self )
+                        break if !cmd.applicable?
+                        if cmd.cmdalias
+                            parent.add_command( Alias.new( cmd.cmdalias, cmd ) )
+                        end
+                        add_command( cmd )
+                        cmd.load_commands( "#{path}/#{cmd.name}", parentmod, cmd.name.capitalize )
+                        break
+                    elsif tmp == BuildTool::Commands::Base
+                        cmd = obj.new( self )
+                        break if !cmd.applicable?
+                        if cmd.cmdalias
+                            parent.add_command( Alias.new( cmd.cmdalias, cmd ) )
+                        end
+                        add_command( cmd )
+                        break
+                    end
+                    tmp = tmp.superclass
                 end
-                return if !cmd.applicable?
+            end
 
-                if cmd.cmdalias
-                    parent.add_command( Alias.new( cmd.cmdalias, cmd ) )
-                end
-                if cmd.is_a?( SubCommands )
-                    cmd.load_commands( "#{path}/#{mod}", "#{parentmod}::#{mod.capitalize}" )
-                end
-                add_command( cmd )
-            }
         end
 
     end # class SubCommands
 
-
     #
     # 
     #
@@ -632,6 +772,10 @@ module BuildTool; module Commands;
             return 0
         end
 
+        def fullname
+            nil
+        end
+
     end # class Shell