Class Index [+]

Quicksearch

Capistrano::Deploy::Strategy::Copy

This class implements the strategy for deployments which work by preparing the source code locally, compressing it, copying the file to each target host, and uncompressing it to the deployment directory.

By default, the SCM checkout command is used to obtain the local copy of the source code. If you would rather use the export operation, you can set the :copy_strategy variable to :export.

  set :copy_strategy, :export

For even faster deployments, you can set the :copy_cache variable to true. This will cause deployments to do a new checkout of your repository to a new directory, and then copy that checkout. Subsequent deploys will just resync that copy, rather than doing an entirely new checkout. Additionally, you can specify file patterns to exclude from the copy when using :copy_cache; just set the :copy_exclude variable to a file glob (or an array of globs).

  set :copy_cache, true
  set :copy_exclude, ".git/*"

Note that :copy_strategy is ignored when :copy_cache is set. Also, if you want the copy cache put somewhere specific, you can set the variable to the path you want, instead of merely ‘true’:

  set :copy_cache, "/tmp/caches/myapp"

This deployment strategy also supports a special variable, :copy_compression, which must be one of :gzip, :bz2, or :zip, and which specifies how the source should be compressed for transmission to each host.

There is a possibility to pass a build command that will get executed if your code needs to be compiled or something needs to be done before the code is ready to run.

  set :build_script, "make all"

Note that if you use :copy_cache, the :build_script is used on the cache and thus you get faster compilation if your script does not recompile everything.

Constants

Compression

A struct for representing the specifics of a compression type. Commands are arrays, where the first element is the utility to be used to perform the compression or decompression.

Public Instance Methods

build(directory) click to toggle source
    # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 66
66:         def build directory
67:           execute "running build script on #{directory}" do
68:             Dir.chdir(directory) { system(build_script) }
69:           end if build_script
70:         end
check!() click to toggle source
    # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 72
72:         def check!
73:           super.check do |d|
74:             d.local.command(source.local.command) if source.local.command
75:             d.local.command(compress(nil, nil).first)
76:             d.remote.command(decompress(nil).first)
77:           end
78:         end
copy_cache() click to toggle source

Returns the location of the local copy cache, if the strategy should use a local cache + copy instead of a new checkout/export every time. Returns nil unless :copy_cache has been set. If :copy_cache is true, a default cache location will be returned.

    # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 84
84:         def copy_cache
85:           @copy_cache ||= configuration[:copy_cache] == true ?
86:             File.expand_path(configuration[:application], Dir.tmpdir) :
87:             File.expand_path(configuration[:copy_cache], Dir.pwd) rescue nil
88:         end
deploy!() click to toggle source

Obtains a copy of the source code locally (via the # method), compresses it to a single file, copies that file to all target servers, and uncompresses it on each of them into the deployment directory.

    # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 56
56:         def deploy!
57:           copy_cache ? run_copy_cache_strategy : run_copy_strategy
58: 
59:           create_revision_file
60:           compress_repository
61:           distribute!
62:         ensure
63:           rollback_changes
64:         end

Private Instance Methods

build_script() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 225
225:           def build_script
226:             configuration[:build_script]
227:           end
command() click to toggle source

Should return the command(s) necessary to obtain the source code locally.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 249
249:           def command
250:             @command ||= case copy_strategy
251:             when :checkout
252:               source.checkout(revision, destination)
253:             when :export
254:               source.export(revision, destination)
255:             end
256:           end
compress(directory, file) click to toggle source

Returns the command necessary to compress the given directory into the given file.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 302
302:           def compress(directory, file)
303:             compression.compress_command + [file, directory]
304:           end
compress_repository() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 209
209:           def compress_repository
210:             execute "Compressing #{destination} to #{filename}" do
211:               Dir.chdir(copy_dir) { system(compress(File.basename(destination), File.basename(filename)).join(" ")) }
212:             end
213:           end
compression() click to toggle source

The compression method to use, defaults to :gzip.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 287
287:           def compression
288:             remote_tar = configuration[:copy_remote_tar] || 'tar'
289:             local_tar = configuration[:copy_local_tar] || 'tar'
290: 
291:             type = configuration[:copy_compression] || :gzip
292:             case type
293:             when :gzip, :gz   then Compression.new("tar.gz",  [local_tar, 'czf'], [remote_tar, 'xzf'])
294:             when :bzip2, :bz2 then Compression.new("tar.bz2", [local_tar, 'cjf'], [remote_tar, 'xjf'])
295:             when :zip         then Compression.new("zip",     %(zip -qyr), %(unzip -q))
296:             else raise ArgumentError, "invalid compression type #{type.inspect}"
297:             end
298:           end
copy_cache_to_staging_area() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 134
134:           def copy_cache_to_staging_area
135:             execute "copying cache to deployment staging area #{destination}" do
136:               create_destination
137:               Dir.chdir(copy_cache) { copy_files(queue_files) }
138:             end
139:           end
copy_dir() click to toggle source

The directory to which the copy should be checked out

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 265
265:           def copy_dir
266:             @copy_dir ||= File.expand_path(configuration[:copy_dir] || Dir.tmpdir, Dir.pwd)
267:           end
copy_directory(name) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 163
163:           def copy_directory name
164:             FileUtils.mkdir(File.join(destination, name))
165:             copy_files(queue_files(name))
166:           end
copy_exclude() click to toggle source

Specify patterns to exclude from the copy. This is only valid when using a local cache.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 231
231:           def copy_exclude
232:             @copy_exclude ||= Array(configuration.fetch(:copy_exclude, []))
233:           end
copy_file(name) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 168
168:           def copy_file name
169:             FileUtils.ln(name, File.join(destination, name))
170:           end
copy_files(files) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 145
145:           def copy_files files
146:             files.each { |name| process_file(name) }
147:           end
copy_repository_to_local_cache() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 220
220:           def copy_repository_to_local_cache
221:             return refresh_local_cache if File.exists?(copy_cache)
222:             create_local_cache
223:           end
copy_repository_to_server() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 184
184:           def copy_repository_to_server
185:             execute "getting (via #{copy_strategy}) revision #{revision} to #{destination}" do
186:               copy_repository_via_strategy
187:             end
188:           end
copy_repository_via_strategy() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 190
190:           def copy_repository_via_strategy
191:               system(command)
192:           end
copy_strategy() click to toggle source

Returns the value of the :copy_strategy variable, defaulting to :checkout if it has not been set.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 243
243:           def copy_strategy
244:             @copy_strategy ||= configuration.fetch(:copy_strategy, :checkout)
245:           end
create_destination() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 141
141:           def create_destination
142:             FileUtils.mkdir_p(destination)
143:           end
create_local_cache() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 120
120:           def create_local_cache
121:             execute "preparing local cache at #{copy_cache}" do
122:               system(source.checkout(revision, copy_cache))
123:             end
124:           end
create_revision_file() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 205
205:           def create_revision_file
206:             File.open(File.join(destination, "REVISION"), "w") { |f| f.puts(revision) }
207:           end
decompress(file) click to toggle source

Returns the command necessary to decompress the given file, relative to the current working directory. It must also preserve the directory structure in the file.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 309
309:           def decompress(file)
310:             compression.decompress_command + [file]
311:           end
decompress_remote_file() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 313
313:           def decompress_remote_file
314:             run "cd #{configuration[:releases_path]} && #{decompress(remote_filename).join(" ")} && rm #{remote_filename}"
315:           end
destination() click to toggle source

Returns the basename of the release_path, which will be used to name the local copy and archive file.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 237
237:           def destination
238:             @destination ||= File.join(copy_dir, File.basename(configuration[:release_path]))
239:           end
distribute!() click to toggle source

Distributes the file to the remote servers

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 318
318:           def distribute!
319:             upload(filename, remote_filename)
320:             decompress_remote_file
321:           end
excluded_files_contain?(file) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 180
180:           def excluded_files_contain? file
181:             copy_exclude.any? { |p| File.fnmatch(p, file) } or [ ".", ".."].include? File.basename(file)
182:           end
execute(description, &block) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 104
104:           def execute description, &block
105:             logger.debug description
106:             handle_system_errors &block
107:           end
filename() click to toggle source

Returns the name of the file that the source code will be compressed to.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 260
260:           def filename
261:             @filename ||= File.join(copy_dir, "#{File.basename(destination)}.#{compression.extension}")
262:           end
filetype(name) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 153
153:           def filetype name
154:             filetype = File.ftype name
155:             filetype = "file" unless ["link", "directory"].include? filetype
156:             filetype
157:           end
handle_system_errors(&block) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 109
109:           def handle_system_errors &block
110:             block.call
111:             raise_command_failed if last_command_failed?
112:           end
last_command_failed?() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 130
130:           def last_command_failed?
131:             $? != 0
132:           end
pattern_for(directory) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 176
176:           def pattern_for directory
177:             !directory.nil? ? "#{directory}/*" : "*"
178:           end
process_file(name) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 149
149:           def process_file name
150:             send "copy_#{filetype(name)}", name
151:           end
queue_files(directory=nil) click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 172
172:           def queue_files directory=nil
173:             Dir.glob(pattern_for(directory), File::FNM_DOTMATCH).reject! { |file| excluded_files_contain? file }
174:           end
raise_command_failed() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 126
126:           def raise_command_failed
127:             raise Capistrano::Error, "shell command failed with return code #{$?}"
128:           end
refresh_local_cache() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 114
114:           def refresh_local_cache
115:             execute "refreshing local cache to revision #{revision} at #{copy_cache}" do
116:               system(source.sync(revision, copy_cache))
117:             end
118:           end
remote_dir() click to toggle source

The directory on the remote server to which the archive should be copied

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 271
271:           def remote_dir
272:             @remote_dir ||= configuration[:copy_remote_dir] || "/tmp"
273:           end
remote_filename() click to toggle source

The location on the remote server where the file should be temporarily stored.

     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 277
277:           def remote_filename
278:             @remote_filename ||= File.join(remote_dir, File.basename(filename))
279:           end
remove_excluded_files() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 194
194:           def remove_excluded_files
195:             logger.debug "processing exclusions..."
196: 
197:             copy_exclude.each do |pattern|
198:               delete_list = Dir.glob(File.join(destination, pattern), File::FNM_DOTMATCH)
199:               # avoid the /.. trap that deletes the parent directories
200:               delete_list.delete_if { |dir| dir =~ /\/\.\.$/ }
201:               FileUtils.rm_rf(delete_list.compact)
202:             end
203:           end
rollback_changes() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 215
215:           def rollback_changes
216:             FileUtils.rm filename rescue nil
217:             FileUtils.rm_rf destination rescue nil
218:           end
run_copy_cache_strategy() click to toggle source
    # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 92
92:           def run_copy_cache_strategy
93:             copy_repository_to_local_cache
94:             build copy_cache
95:             copy_cache_to_staging_area
96:           end
run_copy_strategy() click to toggle source
     # File lib/capistrano/recipes/deploy/strategy/copy.rb, line 98
 98:           def run_copy_strategy
 99:             copy_repository_to_server
100:             build destination
101:             remove_excluded_files if copy_exclude.any?
102:           end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.