Class: Rake::Task

Inherits:
Object
  • Object
show all
Defined in:
lib/rake/config.rb,
lib/rake/extensions.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.gl_run(*args, &aBlock) ⇒ Object

Execute command (as is) on local_host using greenletters to enable expect like behaviour (useful for dealling with passwords).



653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
 
# File 'lib/rake/config.rb', line 653

def self.gl_run(*args, &aBlock)
  $TRACE = Rake.application.options.trace;

  options = Hash.new;
  if args.last.is_a?(Construct) then 
    raise ConfigurationError, "gl_run should not be passed a Construct";
  elsif args.last.is_a?(Hash)
    options = args.pop;
  end
  Conf.timeout = Hash.new() unless Conf.has_key?(:timeout);
  Conf.timeout.maxTimeout = 10 unless Conf.timeout.has_key?(:maxTimeout);
  if options.has_key?(:timeout) then
    options[:timeout] = Conf.timeout.maxTimeout if Conf.timeout.maxTimeout.to_i < options[:timeout].to_i ;
  else
    options[:timeout] = 10;
  end

  Rake::Application.mesg args.join(' ') if $TRACE
  Rake::Application.mesg "#{options}" if $TRACE && !options.empty?() && options.has_key?(:verbose);

  asyncTriggersBlocks = Array.new;
  if options.has_key? :asyncTriggersBlocks then
    asyncTriggersBlocks = options[:asyncTriggersBlocks];
  end

  exitStatus = 0;
  if options.has_key? :exitStatus then
    exitStatus = options[:exitStatus];
  end

  options[:env] = ENV unless options.has_key?(:env);
  options[:transcript] = Rake::Application.logger unless options.has_key?(:transcript);

  cmdProcess = Greenletters::Process.new(*args, options);
  cmdProcess.start!;

  asyncTriggersBlocks.each do | asyncTriggersBlock |
    if asyncTriggersBlock.kind_of? Proc then
      asyncTriggersBlock.call(cmdProcess);
    end
  end

  aBlock.call(cmdProcess) unless aBlock.nil?;

  cmdProcess.wait_for(:exit, exitStatus);

  cmdProcess
end

.local_sh(*args, &aBlock) ⇒ Object

Execute command using sh on local_host using greenletters.



638
639
640
641
642
643
644
645
646
647
648
 
# File 'lib/rake/config.rb', line 638

def self.local_sh(*args, &aBlock)
  options = if args.last.is_a?(Hash) then args.pop else {} end
  options = Conf.sh.data.merge(options);
  cmd     = [options[:command], 
             options[:cmdOptions],
             "-c", 
             args.flatten.join(' ')
            ].flatten

  gl_run(*cmd, options, &aBlock);
end

.remote_ssh(*args, &aBlock) ⇒ Object

Execute command using ssh to remote_host using greenletters.



616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
 
# File 'lib/rake/config.rb', line 616

def self.remote_ssh(*args, &aBlock)
  options = if args.last.is_a?(Hash) then args.pop else {} end
  options = Conf.ssh.data.merge(options);
  options[:timeout] = 10 unless options.has_key?(:timeout);
  sshPort = Array.new();
  sshPort = [ '-p', options[:remotePort]] if options.has_key?(:remotePort);
  cmd     = [options[:command], 
             options[:cmdOptions], 
             '-l',
             options[:userId],
             sshPort,
             options[:remoteHost]
            ].flatten

  gl_run(*cmd, options) do | p |
    p.wait_for(:output, Regexp.new(options[:commandPromptRegExp]));
    Rake::Application.mesg args.flatten.join(' ') if Rake.application.options.trace;
    p.puts args.flatten.join(' ') + '; exit';
  end
end

.rsync_from_remote(remotePath, localPath, options = {}, &aBlock) ⇒ Object

Execute the rsync command on the arguments provided using greenletters.



603
604
605
606
607
608
609
610
611
612
613
 
# File 'lib/rake/config.rb', line 603

def self.rsync_from_remote(remotePath, localPath, options = {}, &aBlock)
  options = Conf.rsync.data.merge(options);
  options[:timeout] = 10 unless options.has_key?(:timeout);
  cmd     = [options[:command], 
             options[:cmdOptions], 
             "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
             localPath,
            ].flatten

  gl_run(*cmd, options, &aBlock);
end

.rsync_to_remote(localPath, remotePath, options = {}, &aBlock) ⇒ Object

Execute the rsync command on the arguments provided using greenletters.



587
588
589
590
591
592
593
594
595
596
597
598
599
600
 
# File 'lib/rake/config.rb', line 587

def self.rsync_to_remote(localPath, remotePath, options = {}, &aBlock)
  if localPath =~ /\*/ then
    localPath = Dir.glob(localPath);
  end
  options = Conf.rsync.data.merge(options);
  options[:timeout] = 10 unless options.has_key?(:timeout);
  cmd     = [options[:command], 
             options[:cmdOptions], 
             localPath,
             "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
            ].flatten

  gl_run(*cmd, options, &aBlock);
end

.scp_from_remote(remotePath, localPath, options = {}, &aBlock) ⇒ Object

Execute the rsync command on the arguments provided using greenletters.



574
575
576
577
578
579
580
581
582
583
584
 
# File 'lib/rake/config.rb', line 574

def self.scp_from_remote(remotePath, localPath, options = {}, &aBlock)
  options = Conf.scp.data.merge(options);
  options[:timeout] = 10 unless options.has_key?(:timeout);
  cmd     = [options[:command], 
             options[:cmdOptions], 
             "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
             localPath,
            ].flatten

  gl_run(*cmd, options, &aBlock);
end

.scp_to_remote_scp(localPath, remotePath, options = {}, &aBlock) ⇒ Object

Execute the rsync command on the arguments provided using greenletters.



561
562
563
564
565
566
567
568
569
570
571
 
# File 'lib/rake/config.rb', line 561

def self.scp_to_remote_scp(localPath, remotePath, options = {}, &aBlock)
  options = Conf.scp.data.merge(options);
  options[:timeout] = 10 unless options.has_key?(:timeout);
  cmd     = [options[:command], 
             options[:cmdOptions], 
             localPath,
             "#{options[:userId]}@#{options[:remoteHost]}:#{remotePath}",
            ].flatten

  gl_run(*cmd, options, &aBlock);
end

Instance Method Details

#execute(args = nil) ⇒ Object

Execute the actions associated with this task.



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/rake/extensions.rb', line 250

def execute(args=nil)
  args ||= EMPTY_TASK_ARGS
  if application.options.dryrun then
    Rake::Application.mesg "** Execute (dry run) #{name}"
    return
  end
  if application.options.trace then
    Rake::Application.mesg "** Execute #{name}"
  end
  application.enhance_with_matching_rule(name) if @actions.empty?
  @actions.each do |act|
    case act.arity
    when 1
      act.call(self)
    else
      act.call(self, args)
    end
  end
end

#invoke_with_call_chain(task_args, invocation_chain) ⇒ Object

Same as invoke, but explicitly pass a call chain to detect circular dependencies.



233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/rake/extensions.rb', line 233

def invoke_with_call_chain(task_args, invocation_chain) # :nodoc:
  new_chain = InvocationChain.append(self, invocation_chain)
  @lock.synchronize do
    if application.options.trace then
      Rake::Application.mesg "** Invoke #{name} #{format_trace_flags}"
    end
    return if @already_invoked
    @already_invoked = true
    invoke_prerequisites(task_args, new_chain)
    execute(task_args) if needed?
  end
rescue Exception => ex
  add_chain_to(ex, new_chain)
  raise ex
end