Parent

Included Modules

Class Index [+]

Quicksearch

Capistrano::Transfer

Attributes

sessions[R]
options[R]
callback[R]
transport[R]
direction[R]
from[R]
to[R]
logger[R]
transfers[R]

Public Class Methods

new(direction, from, to, sessions, options={}, &block) click to toggle source
    # File lib/capistrano/transfer.rb, line 26
26:     def initialize(direction, from, to, sessions, options={}, &block)
27:       @direction = direction
28:       @from      = from
29:       @to        = to
30:       @sessions  = sessions
31:       @options   = options
32:       @callback  = block
33: 
34:       @transport = options.fetch(:via, :sftp)
35:       @logger    = options.delete(:logger)
36: 
37:       @session_map = {}
38: 
39:       prepare_transfers
40:     end
process(direction, from, to, sessions, options={}, &block) click to toggle source
    # File lib/capistrano/transfer.rb, line 10
10:     def self.process(direction, from, to, sessions, options={}, &block)
11:       new(direction, from, to, sessions, options, &block).process!
12:     end

Public Instance Methods

active?() click to toggle source
    # File lib/capistrano/transfer.rb, line 70
70:     def active?
71:       transfers.any? { |transfer| transfer.active? }
72:     end
operation() click to toggle source
    # File lib/capistrano/transfer.rb, line 74
74:     def operation
75:       "#{direction}load"
76:     end
process!() click to toggle source
    # File lib/capistrano/transfer.rb, line 42
42:     def process!
43:       loop do
44:         begin
45:           break unless process_iteration { active? }
46:         rescue Exception => error
47:           if error.respond_to?(:session)
48:             handle_error(error)
49:           else
50:             raise
51:           end
52:         end
53:       end
54: 
55:       failed = transfers.select { |txfr| txfr[:failed] }
56:       if failed.any?
57:         hosts = failed.map { |txfr| txfr[:server] }
58:         errors = failed.map { |txfr| "#{txfr[:error]} (#{txfr[:error].message})" }.uniq.join(", ")
59:         error = TransferError.new("#{operation} via #{transport} failed on #{hosts.join(',')}: #{errors}")
60:         error.hosts = hosts
61: 
62:         logger.important(error.message) if logger
63:         raise error
64:       end
65: 
66:       logger.debug "#{transport} #{operation} complete" if logger
67:       self
68:     end
sanitized_from() click to toggle source
    # File lib/capistrano/transfer.rb, line 78
78:     def sanitized_from
79:       if from.responds_to?(:read)
80:         "#<#{from.class}>"
81:       else
82:         from
83:       end
84:     end
sanitized_to() click to toggle source
    # File lib/capistrano/transfer.rb, line 86
86:     def sanitized_to
87:       if to.responds_to?(:read)
88:         "#<#{to.class}>"
89:       else
90:         to
91:       end
92:     end

Private Instance Methods

handle_error(error) click to toggle source
     # File lib/capistrano/transfer.rb, line 205
205:       def handle_error(error)
206:         raise error if error.message.include?('expected a file to upload')
207: 
208:         transfer = session_map[error.session]
209:         transfer[:error] = error
210:         transfer[:failed] = true
211: 
212:         case transport
213:         when :sftp then transfer.abort!
214:         when :scp  then transfer.close
215:         end
216:       end
normalize(argument, session) click to toggle source
     # File lib/capistrano/transfer.rb, line 192
192:       def normalize(argument, session)
193:         if argument.is_a?(String)
194:           argument.gsub(/\$CAPISTRANO:HOST\$/, session.xserver.host)
195:         elsif argument.respond_to?(:read)
196:           pos = argument.pos
197:           clone = StringIO.new(argument.read)
198:           clone.pos = argument.pos = pos
199:           clone
200:         else
201:           argument
202:         end
203:       end
prepare_scp_transfer(from, to, session) click to toggle source
     # File lib/capistrano/transfer.rb, line 118
118:       def prepare_scp_transfer(from, to, session)
119:         real_callback = callback || Proc.new do |channel, name, sent, total|
120:           logger.trace "[#{channel[:host]}] #{name}" if logger && sent == 0
121:         end
122: 
123:         channel = case direction
124:           when :up
125:             session.scp.upload(from, to, options, &real_callback)
126:           when :down
127:             session.scp.download(from, to, options, &real_callback)
128:           else
129:             raise ArgumentError, "unsupported transfer direction: #{direction.inspect}"
130:           end
131: 
132:         channel[:server] = session.xserver
133:         channel[:host]   = session.xserver.host
134: 
135:         return channel
136:       end
prepare_sftp_transfer(from, to, session) click to toggle source
     # File lib/capistrano/transfer.rb, line 164
164:       def prepare_sftp_transfer(from, to, session)
165:         SFTPTransferWrapper.new(session) do |sftp|
166:           real_callback = Proc.new do |event, op, *args|
167:             if callback
168:               callback.call(event, op, *args)
169:             elsif event == :open
170:               logger.trace "[#{op[:host]}] #{args[0].remote}"
171:             elsif event == :finish
172:               logger.trace "[#{op[:host]}] done"
173:             end
174:           end
175: 
176:           opts = options.dup
177:           opts[:properties] = (opts[:properties] || {}).merge(
178:             :server  => session.xserver,
179:             :host    => session.xserver.host)
180: 
181:           case direction
182:           when :up
183:             sftp.upload(from, to, opts, &real_callback)
184:           when :down
185:             sftp.download(from, to, opts, &real_callback)
186:           else
187:             raise ArgumentError, "unsupported transfer direction: #{direction.inspect}"
188:           end
189:         end
190:       end
prepare_transfers() click to toggle source
     # File lib/capistrano/transfer.rb, line 100
100:       def prepare_transfers
101:         logger.info "#{transport} #{operation} #{from} -> #{to}" if logger
102: 
103:         @transfers = sessions.map do |session|
104:           session_from = normalize(from, session)
105:           session_to   = normalize(to, session)
106: 
107:           session_map[session] = case transport
108:             when :sftp
109:               prepare_sftp_transfer(session_from, session_to, session)
110:             when :scp
111:               prepare_scp_transfer(session_from, session_to, session)
112:             else
113:               raise ArgumentError, "unsupported transport type: #{transport.inspect}"
114:             end
115:         end
116:       end
session_map() click to toggle source
    # File lib/capistrano/transfer.rb, line 96
96:       def session_map
97:         @session_map
98:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.