build-tool 0.5.7 → 0.6.0.rc1

data/lib/build-tool/commands.rb

@@ -1,3 +1,7 @@
+# -*- coding: UTF-8 -*-
+
+require 'mj/tools/ssh'
+
 require "build-tool/singleton"
 require 'build-tool/errors'
 require 'build-tool/command_actions'
@@ -76,6 +80,7 @@ class Base
         class UsageError < BuildTool::Error; end
 
         include HelpText
+        include ANSI::Code
 
         def <=> (other)
             return self.name <=> other.name
@@ -94,6 +99,7 @@ def initialize(parent = nil)
             @skip_command = false
             @parent = parent
             @cmd = nil
+            setup_options
         end
 
         def applicable?
@@ -107,37 +113,7 @@ def configuration
         def initialize_options
         end
 
-        def complete_readline_1_8( string )
-            # Readline in 1.8 does not provide all needed information. We have to hand made
-            # it ourselves. We get the complete commandline here.
-
-            # We want the complete commandline in line_buffer
-            line_buffer = string
-            # An array of completed arguments/options in args
-            args = Shellwords.shellwords( line_buffer )
-
-            # And the string to complete in string. If the last character is a space we
-            # complete from that. if not we take the last arg
-            if line_buffer.empty? or line_buffer[-1] == 32
-                args << ""
-            end
-
-            do_complete_1_8( args )
-        end
-
-        def do_complete_1_8( args )
-            # puts "do_complete_1_8( #{args.inspect} )"
-            compl = complete_arguments( args )
-            if compl.length >= 1
-                return compl.collect do |res|
-                    args.dup[0..-2].push(res).join(" ")
-                end
-            else
-                return []
-            end
-        end
-
-        def complete_readline_1_9( string )
+        def complete_readline( string )
             # We have three sources of information (ruby 1.9 only)
             # argument:
             #   See Readline::completer_word_break_characters . The part
@@ -148,7 +124,7 @@ def complete_readline_1_9( string )
             #   The position of the cursor in commandline
             # Ruby 1.9 <start>
             # First check if we have to complete the first shellword (command)
-            args = Shellwords.shellwords( string )
+            args = Shellwords.shellwords( Readline.line_buffer )
 
             # And the string to complete in string. If the last character is a space we
             # complete from that. if not we take the last arg
@@ -156,19 +132,7 @@ def complete_readline_1_9( string )
                 args << ""
             end
 
-            do_complete_1_9( args )
-        end
-
-        def do_complete_1_9( args )
-            return complete_arguments( args )
-        end
-
-        def complete( string )
-            if Readline.respond_to? "line_buffer"
-                complete_readline_1_9( string )
-            else
-                complete_readline_1_8( string )
-            end
+            do_complete( args )
         end
 
         def complete_arguments( args )
@@ -187,6 +151,11 @@ def complete_arguments( args )
             res.flatten.compact.sort
         end
 
+        def do_complete( args )
+            return complete_arguments( args )
+            do_complete( args )
+        end
+
         def each_option
             list = options.instance_variable_get( "@stack" )
             if block_given?
@@ -197,7 +166,11 @@ def each_option
                     end
                 end
             else
-                list.collect { |l| l.list.collect { |sw| sw unless sw.is_a? String } }.flatten.compact
+                list.collect { |l|
+                    l.list.collect { |sw|
+                        sw unless not sw.is_a? OptionParser::Switch
+                    }
+                }.flatten.compact
             end
         end
 
@@ -217,40 +190,49 @@ def summarize
         # Cleanup after vcs_access
         def cleanup_after_vcs_access
             if MJ::Tools::SSH::has_keys?
-                logger.info ""
-                logger.info "#### Cleaning up the ssh keys"
+                info( "" )
+                info( "#### Cleaning up the ssh keys" )
                 MJ::Tools::SSH::keys.each do |file|
-                    logger.info "  - Removing key #{file}"
+                    info( "  - Removing key #{file}" )
                 end
                 MJ::Tools::SSH::cleanup()
             end
         end
 
-        def execute( args )
+        def setup_options
             @options = OptionParser.new
             @options.set_program_name( name )
-            @options.separator long_description if long_description
-
-            @parsing = true
+            if long_description
+                @options.separator ''
+                @options.separator long_description
+            end
             initialize_options
+        end
+
+        def execute( args )
+            # Reinitialize the option parser.
+            setup_options
             begin
                 realargs =  @options.parse( args )
             rescue OptionParser::ParseError => e
-                logger.error( "#{e}" )
+                error( "#{name}: #{e}" )
                 @skip_command = true
             end
-            @parsing = false
 
             setup_command
 
             # 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
+                # Initialize the command log if necessary
+                if log?
+                    @cmd = BuildTool::History::CommandLog.new(
+                        :command => "#{self.fullname} #{args.join( ' ')}",
+                        :logdir => log_directory.to_s.encode( 'UTF-8' ) )
+                    @cmd.started
+                end
+                # Now execute the command
                 begin
                     rc = do_execute( realargs )
                     if rc != 0
@@ -258,8 +240,8 @@ def execute( args )
                     end
                 rescue BuildTool::Error => e
                     state = BuildTool::History::CommandLog::FINISHED_WITH_ERRORS
-                    logger.error   e.message
-                    logger.verbose e.backtrace.join("\n")
+                    error( e.message )
+                    verbose( e.backtrace.join("\n") )
                     rc = -1
                 rescue Interrupt => e
                     state = BuildTool::History::CommandLog::CANCELED_BY_USER
@@ -303,7 +285,7 @@ def log?
 
         def show_help( args = [] )
             # Just ignore potential arguments
-            say @options.help
+            info( options.help )
             skip_command
             return 0
         end
@@ -314,12 +296,42 @@ def skip_command
             @skip_command = true
         end
 
-        def say( *args )
+        # Print out a normal message (if enabled)
+        def info( *args )
             logger.info( *args )
         end
 
+        # Print out a verbose message (if enabled)
+        def verbose( *args )
+            logger.verbose( *args )
+        end
+
+        # Print out a verbose message (if enabled)
+        def trace( *args )
+            logger.trace( *args )
+        end
+
+        # Print out a verbose message (if enabled)
+        def debug( *args )
+            logger.debug( *args )
+        end
+
+        def debug2( *args )
+            logger.debug2( *args )
+        end
+
+        # Print out a warning message (if enabled)
+        def warn( *args )
+            logger.warn( *args )
+        end
+
+        # Print out a error message (if enabled)
+        def error( *args )
+            logger.error( *args )
+        end
+
         def usage( error )
-            logger.error error
+            error( error )
             show_help
             return -2
         end
@@ -348,12 +360,11 @@ def initialize( *args )
         end
 
         def initialize_options
+            options.separator ''
             options.separator "Common options"
 
             options.on( "-v", "--verbose", "Enable verbose output" ) do
-                Logging.appenders['stdout'].level = [ Logging.appenders['stdout'].level-1, 0 ].max
-                Logging.logger['MJ::Logging::LoggerAdapter'].level =
-                    [ Logging.logger['MJ::Logging::LoggerAdapter'].level - 1, 0 ].max
+                Logging.appenders['stdout'].level = [ Logging.appenders['stdout'].level - 1, 0 ].max()
             end
 
             options.on( nil, "--dry-run", "Enable dry run." ) do
@@ -365,10 +376,20 @@ def initialize_options
             end
         end
 
+        # Complete buildsets
+        def complete_buildsets( name )
+            if name == ':all'
+                return complete_modules( '*' )
+            end
+        end
+
         # Gathers all modules currently known.
         #
         # @param all Return template modules too.
         def complete_modules( name, include_templates = false )
+            if name.start_with? ':'
+                return complete_buildsets( name )
+            end
             res = []
             found = false
             should_be_unique = false
@@ -388,14 +409,15 @@ def complete_modules( name, include_templates = false )
                 elsif mod.name == name
                     found = true
                     should_be_unique = true
+                    take_module = true
+                elsif name == '*'
+                    found = true
                     # Now check if it is active.
                     next if !( mod.active? || @all )
                     take_module = true
                 elsif mod.name.end_with?( "/#{name}" )
                     found = true
                     should_be_unique = true
-                    # Now check if it is active.
-                    next if !( mod.active? || @all )
                     take_module = true
                 end
 
@@ -422,7 +444,7 @@ def complete_modules( name, include_templates = false )
             end
 
             # Give a warning if all modules where 
-            logger.warn "All modules for #{name} are inactive! Will ignore it." if res.empty?
+            warn( "All modules for #{name} are inactive! Will ignore it." ) if res.empty?
             return res
         end
 
@@ -439,13 +461,13 @@ def while_logging_to( dir, fname, level, &block )
             got_exception = false
             # Only create a logfile if we do real work
             if log?
-                dirname = log_directory.to_s
-                dirname = "#{log_directory.to_s}/#{dir}" if dir
+                dirname = log_directory
+                dirname += dir if dir
                 FileUtils.mkdir_p( dirname )
                 Logging.logger['root'].add_appenders(
                     Logging.appenders.file(
                         fname,
-                        :filename => dirname + '/' + fname,
+                        :filename => dirname + fname,
                         :layout => Logging::Layouts::Pattern.new( :pattern => '%m\n' ),
                         :level => level ))
             end
@@ -453,18 +475,18 @@ def while_logging_to( dir, fname, level, &block )
             begin
                 yield
             rescue Interrupt => e
-                logger.error "User Interrupt!"
+                error( "User Interrupt!" )
             rescue BuildTool::Error => e
-                logger.error   "#{e.message}"
+                error( "#{e.message}" )
                 got_exception = true
                 raise e
             rescue Exception => e
-                logger.error   "#{e.class}:#{e.message}"
+                error( "#{e.class}:#{e.message}" )
                 got_exception = true
                 raise e
             ensure
                 Logging.logger['root'].remove_appenders( fname )
-                logger.info("More information in #{dirname}/#{fname}") if got_exception
+                info( "More information in #{dirname}/#{fname}" ) if got_exception
             end
         end
 
@@ -527,7 +549,8 @@ def write( event )
                     @pbar.clear()       if @pbar
                     @oldlogger.append(event)
                 rescue Exception => e
-                    puts e
+                    error( e )
+                    verbose( e.backtrace.join("\n") )
                 end
             end
         end
@@ -545,7 +568,7 @@ def initialize( *args )
         end
 
         def initialize_options
-            options.on( "--resume-from [module]", "Skip all module before module." ) { |t|
+            options.on( "--resume-from MODULE", "Skip all module before module." ) { |t|
                 begin
                     @resume_from = complete_module( t )
                 rescue UsageError => e
@@ -553,7 +576,7 @@ def initialize_options
                 end
                 raise UsageError, "Both --resume-from and --resume-after specified!" if @resume_after
                 }
-            options.on( "--resume-after [module]", "Skip all module before and including module." ) { |t|
+            options.on( "--resume-after MODULE", "Skip all module before and including module." ) { |t|
                 begin
                     @resume_after = complete_module( t )
                 rescue UsageError => e
@@ -592,14 +615,27 @@ def do_execute( args )
             end
 
             # 2. Check if the modules are ready
-            logger.info( '#### Checking for obstacles' )
+            info( '#### Checking for obstacles'  )
             isready = true
             ModuleProgressbar.new( 'Modules', modules ) do |mod|
-                isready &= is_module_ready?( mod )
+                begin
+                    isready &= is_module_ready?( mod )
+                rescue Interrupt => e
+                    info( "User Interrupt"  )
+                    return -1
+                rescue BuildTool::Error => e
+                    error( e.message )
+                    verbose( e.backtrace.join("\n") )
+                    raise
+                rescue Exception => e
+                    error( "#{e.class}:#{e.message}" )
+                    verbose( e.backtrace.join("\n") )
+                    raise
+                end
             end
 
             if !isready
-                logger.error "There were some problems detected. Exiting."
+                error( "There were some problems detected. Exiting." )
                 return -1
             end
 
@@ -608,13 +644,21 @@ def do_execute( args )
                 begin
                     isready &= prepare_module( mod )
                 rescue Interrupt => e
-                    logger.info( "User Interrupt" )
+                    info( "User Interrupt"  )
                     return -1
+                rescue BuildTool::Error => e
+                    error( e.message )
+                    verbose( e.backtrace.join("\n") )
+                    raise
+                rescue Exception => e
+                    error( "#{e.class}:#{e.message}" )
+                    verbose( e.backtrace.join("\n") )
+                    raise
                 end
             end
 
             if !isready
-                logger.error "Unexpected problems encountered. Exiting."
+                error( "Unexpected problems encountered. Exiting." )
                 return -1
             end
 
@@ -630,25 +674,25 @@ def do_execute( args )
 
                         begin
 
-                            logger.info ""
-                            logger.info "#### Module #{mod.name} (#{index+1}/#{modules.size})"
+                            info( "" )
+                            info( "#### Module #{mod.name} (#{index+1}/#{modules.size})" )
                             do_execute_module( mod )
                         rescue Interrupt => e
                             raise e
                         rescue BuildTool::Error => e
-                            logger.error   e.message
-                            logger.verbose e.backtrace.join("\n")
+                            error( e.message )
+                            verbose( e.backtrace.join("\n") )
                             @failed_modules << mod.name
                             rc = -1
                             break if @stop_on_error
                         rescue Exception => e
-                            logger.error   "#{e.class}:#{e.message}"
-                            logger.verbose e.backtrace.join("\n")
+                            error( "#{e.class}:#{e.message}" )
+                            verbose( e.backtrace.join("\n") )
                             @failed_modules << mod.name
                             rc = -1
                             break if @stop_on_error
                         ensure
-                            logger.info "#### Module #{mod.name} finished"
+                            info( "#### Module #{mod.name} finished" )
                         end
                     end
 
@@ -661,12 +705,12 @@ def do_execute( args )
         end
 
         def summarize
-            logger.info ""
+            info( "" )
             if !@failed_modules.empty?
-                logger.info "#### Finished with errors"
-                logger.info "Failed modules:\n\t#{ @failed_modules.join( "\n\t" ) }"
+                info( "#### Finished with errors" )
+                info( "Failed modules:\n\t#{ @failed_modules.join( "\n\t" ) }" )
             else
-                logger.info "#### Finished without errors"
+                info( "#### Finished without errors" )
             end
         end
 
@@ -716,8 +760,8 @@ def make( mod, *args )
         # Call the #rebase method of the module.
         #
         # @param [Object] mod The module to use
-        def rebase( mod )
-            ModuleActions::Rebase.new( self, mod ).do
+        def rebase( mod, verbose = false )
+            ModuleActions::Rebase.new( self, mod, verbose ).do
         end
 
         # Call the #reconfigure method of the module.
@@ -727,11 +771,18 @@ def reconfigure( mod )
             ModuleActions::Reconfigure.new( self, mod ).do
         end
 
-        # Call the #clear_build_directory method of the module.
+        # Call the #remove_build_directory method of the module.
+        #
+        # @param [Object] mod The module to use
+        def remove_build_directory( mod, force = false )
+            ModuleActions::RemoveBuildDirectory.new( self, mod, force ).do
+        end
+
+        # Call the #remove_source_directory method of the module.
         #
         # @param [Object] mod The module to use
-        def remove_build_directory( mod )
-            ModuleActions::RemoveBuildDirectory.new( self, mod ).do
+        def remove_source_directory( mod, force = false )
+            ModuleActions::RemoveSourceDirectory.new( self, mod, force ).do
         end
 
     end
@@ -747,8 +798,21 @@ def initialize( *args )
             @commands = []
         end
 
+        def initialize_options()
+            options.banner = "Usage: #{name} [OPTIONS]... COMMAND [COMMAND OPTIONS]..."
+
+            options.on( "-h", "--help", "Show this help text." ) do
+                show_help
+            end
+
+            options.separator( '' )
+            options.separator( "Use '#{name} help' to see a list of commands" )
+
+            super()
+        end
+
         def add_command( cmd )
-            logger.trace "#{name}: Adding command #{cmd.name}"
+            trace( "#{name}: Adding command #{cmd.name}" )
             @commands << cmd
         end
 
@@ -765,77 +829,63 @@ def get_command( name )
         end
 
         def execute( args )
-            # There has to be a subcommand
-            if args.length == 0
-                return show_help
+            debug2( '%s: %s' % [ name, args ] )
+
+            # Reinitialize the option parser.
+            setup_options
+
+            # Parse our options. Store the rest for later.
+            begin
+                args = @options.order( args )
+            rescue OptionParser::ParseError => e
+                error( "#{name}: #{e}" )
+                return -1
             end
 
-            cmd = get_command( args[0] )
-            if cmd.nil?
-                if self.name
-                    raise UsageError, "Unknown command #{args[0]} for #{self.name}"
-                else
-                    raise UsageError, "Unknown command #{args[0]}"
+            setup_command
+
+            begin
+
+                # There has to be a subcommand
+                if args.length == 0
+                    return default_command()
                 end
-            end
-            cmd.execute( args[1..-1] )
-        end
 
-        def do_complete_1_8( args )
-            # puts "#{self.name}.do_complete_1_8( #{args.inspect}"
-            if args.length <= 1
-                # There is only one or no argument. We try to complete to a
-                # command.
-                if subcmd = get_command( args[0] )
-                    # We have a exact match. If we had to complete to get to
-                    # the commands return here. If not forward to the command
-                    if args[0] != subcmd.name
-                        return [ subcmd.name ]
+                # Always accept help as a command
+                return help_commands() if args[0] == 'help'
+
+                # Now follow up with real ones.
+                cmd = get_command( args[0] )
+                if cmd.nil?
+                    if self.name
+                        raise UsageError, "Unknown command #{args[0]} for #{self.name}"
                     else
-                        return subcmd.do_complete_1_8( [""] ).collect do |res|
-                            [ subcmd.name ].push(res).join(" ")
-                        end
-                    end
-                else
-                    # We have a no exact match. Complete the available
-                    # commands
-                    return complete_command( args[0] )
-                end
-            else
-                # At least two arguments are present
-                if subcmd = get_command( args[0] )
-                    # We have a exact match. Forward to that command.
-                    return subcmd.do_complete_1_8( args[1..-1] ).collect do |res|
-                        [ subcmd.name ].push(res).join(" ")
+                        raise UsageError, "Unknown command #{args[0]}"
                     end
-                else
-                    # No exact match. Since there is at least on argument
-                    # behind the current position just keep the user input
-                    # intact.
-                    return []
                 end
+
+                cmd.execute( args[1..-1] )
+            ensure
+
+                teardown_command
             end
         end
 
-        def do_complete_1_9( args )
-            # puts "#{self.name}.do_complete_1_9( #{args.inspect} )"
-            if args.length <= 1
-                if subcmd = get_command( args[0] )
-                    return subcmd.do_complete_1_9( [""] )
-                else
-                    return complete_command( args[0] )
-                end
+        def do_complete( args )
+            cur = args[0]
+            # Check if we have a match for one command
+            if subcmd = get_command( cur )
+                # Check if the commands is complete. If not complete it.
+                return [ subcmd.name() ] if cur != subcmd.name()
+                # It is complete. forward.
+                return subcmd.do_complete( args[1..-1] )
             else
-                if subcmd = get_command( args[0] )
-                    return subcmd.do_complete_1_9( args[1..-1] )
-                else
-                    return args
-                end
+                # No match. Give back possible matches.
+                return complete_command( cur )
             end
         end
 
         def complete_command( cmdname )
-            # puts "#{self.name}.complete_command( #{cmdname.inspect} )"
             cmds = @commands.collect { |com|
                 com.name if com.name.start_with? cmdname
             }.compact
@@ -850,27 +900,8 @@ def complete_arguments( args, string )
             end
         end
 
-        def show_help( args = [] )
-            if args.length == 0
-                @commands.sort.each do |cmd|
-                    say "%-20s: %s" % [ cmd.name, cmd.description ]
-                end
-            else
-                if cmd = get_command( args[0] )
-                    cmd.show_help( args[1..-1] )
-                else
-                    if self.name
-                        raise UsageError, "Unknown command #{args[0]} for #{self.name}"
-                    else
-                        raise UsageError, "Unknown command #{args[0]}"
-                    end
-                end
-            end
-            return 0
-        end
-
         def load_commands( path, parentmod, submod = nil )
-            logger.debug "load_commands( #{path} #{parentmod.inspect} #{submod.inspect}"
+            debug( "load_commands( #{path} #{parentmod.inspect} #{submod.inspect}" )
             # Load all available ruby files in path
             Dir[  "#{path}/*.rb" ].each do |mod|
                 load "#{mod}"
@@ -913,6 +944,19 @@ def load_commands( path, parentmod, submod = nil )
 
         end
 
+        def show_help()
+            super()
+        end
+
+        def help_commands( args = [] )
+            @commands.sort.each do |cmd|
+                info( "%-20s: %s" % [ cmd.name, cmd.description ] )
+            end
+            return 0
+        end
+
+        alias :default_command :help_commands
+
     end # class SubCommands
 
     #
@@ -920,23 +964,73 @@ def load_commands( path, parentmod, submod = nil )
     #
     class Shell < SubCommands
 
-        name   "shell"
+        def name
+            return Pathname.new($0).basename.to_s
+        end
 
-        def execute( args )
-            if args.length == 0
-                return cli
+        def initialize_options
+            options.banner = "Usage: #{name} [OPTIONS]... COMMAND [COMMAND OPTIONS]..."
+
+            options.separator ''
+            options.separator "Options"
+
+            options.on( "-v", "--verbose", "Enable verbose output" ) do
+                Logging.appenders['stdout'].level = [ Logging.appenders['stdout'].level - 1, 0 ].max()
             end
-            super
+
+            options.on( nil, "--dry-run", "Enable dry run." ) do
+                $noop = true
+            end
+
+            options.on( "-V", "--version", "Print version information." ) do
+                show_version
+            end
+
+            options.on( "--ionice", "Set io io niceness to idle (3)." ) { |n|
+
+                pid = Process.pid()
+                system( "ionice -p #{pid} -c 3" )
+                cur = `ionice -p #{pid}`
+                info( 'Process priority (io niceness): %s' % cur )
+            }
+
+            options.on( "--nice N", "Set niceness to N." ) { |n|
+                if not /^[0-9]+$/.match( n )
+                    raise OptionParser::ParseError.new( 'value "%s" is not a number' %  n )
+                end
+
+                # Set the priority
+                Process.setpriority( Process::PRIO_PROCESS, 0, n.to_i() )
+
+                # Check if it worked.
+                cur = Process.getpriority( Process::PRIO_PROCESS, 0 )
+                if n.to_i() != cur
+                    warn( 'Process priority (niceness): %d (%d was given)' % [ cur, n ] )
+                else
+                    info( 'Process priority (niceness): %d' % [ cur ] )
+                end
+            }
+
+            options.on( "--debug-db", "Debug the database." ) do
+                Logging.logger['ActiveRecord'].level = :debug
+            end
+
+            super()
+        end
+
+        def setup_command
+            # And the commands require all that database related stuff.
+            load_commands( Application::instance.application_root.join( "lib/build-tool/commands" ), BuildTool::Commands )
+        end
+
+        def show_version
+            @skip_command = true
+            info( "#{name()}: Version #{BuildTool::VERSION}" )
         end
 
         def cli
             require 'readline'
-
-            Readline.completion_proc = method(:complete)
-            if !Readline.respond_to? "line_buffer"
-                # 1.8 :(
-                Readline.completer_word_break_characters = "\x00"
-            end
+            Readline.completion_proc = method(:complete_readline)
 
             while true
 
@@ -958,13 +1052,13 @@ def cli
                     execute Shellwords.shellwords( line )
 
                 rescue BuildTool::Error => e
-                    logger.error e.message
-                    logger.verbose e.backtrace.join("\n")
+                    error( e.message )
+                    verbose( e.backtrace.join("\n") )
                 rescue StandardError => e
-                    logger.error e.message
-                    logger.error e.backtrace.join("\n")
+                    error( e.message )
+                    error( e.backtrace.join("\n") )
                 rescue Interrupt => e
-                    say "Use CTRL-D for exit!"
+                    info( "Use CTRL-D for exit!" )
                 end
 
             end
@@ -972,9 +1066,7 @@ def cli
             return 0
         end
 
-        def fullname
-            nil
-        end
+        alias :default_command :cli
 
     end # class Shell