Class: Chef::Provider::Deploy

Inherits:
Chef::Provider show all
Includes:
Mixin::Command, Mixin::FromFile, Mixin::RecipeDefinitionDSLCore
Defined in:
lib/chef/provider/deploy.rb,
lib/chef/provider/deploy/revision.rb,
lib/chef/provider/deploy/timestamped.rb

Direct Known Subclasses

Revision, Timestamped

Defined Under Namespace

Classes: Revision, Timestamped

Instance Attribute Summary collapse

Attributes inherited from Chef::Provider

#action, #current_resource, #new_resource, #run_context

Instance Method Summary collapse

Methods included from Mixin::Command

#chdir_or_tmpdir, #handle_command_failures, #output_of_command, #run_command, #run_command_with_systems_locale

Methods included from Mixin::Command::Windows

#popen4

Methods included from Mixin::Command::Unix

#popen4

Methods included from Mixin::FromFile

#class_from_file, #from_file

Methods included from Mixin::RecipeDefinitionDSLCore

#method_missing

Methods included from Mixin::Language

#data_bag, #data_bag_item, #platform?, #platform_family?, #search, #value_for_platform, #value_for_platform_family

Methods included from Mixin::ConvertToClassName

#convert_to_class_name, #convert_to_snake_case, #filename_to_qualified_string, #snake_case_basename

Methods inherited from Chef::Provider

#action_nothing, build_from_file, #cleanup_after_converge, #converge, #cookbook_name, #events, #node, #process_resource_requirements, #requirements, #resource_collection, #run_action, #whyrun_mode?

Methods included from Mixin::EnforceOwnershipAndPermissions

#access_controls, #enforce_ownership_and_permissions

Constructor Details

#initialize(new_resource, run_context) ⇒ Deploy

Returns a new instance of Deploy.



34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/chef/provider/deploy.rb', line 34

def initialize(new_resource, run_context)
  super(new_resource, run_context)

  # will resolve to ither git or svn based on resource attributes , 
  # and will create a resource corresponding to that provider 
  @scm_provider = new_resource.scm_provider.new(new_resource, run_context)

  # @configuration is not used by Deploy, it is only for backwards compat with
  # chef-deploy or capistrano hooks that might use it to get environment information
  @configuration = @new_resource.to_hash
  @configuration[:environment] = @configuration[:environment] && @configuration[:environment]["RAILS_ENV"]
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Chef::Mixin::RecipeDefinitionDSLCore

Instance Attribute Details

#previous_release_path ⇒ Object (readonly)

Returns the value of attribute previous_release_path.



32
33
34
 
# File 'lib/chef/provider/deploy.rb', line 32

def previous_release_path
  @previous_release_path
end

#release_path ⇒ Object (readonly)

Returns the value of attribute release_path.



32
33
34
 
# File 'lib/chef/provider/deploy.rb', line 32

def release_path
  @release_path
end

#scm_provider ⇒ Object (readonly)

Returns the value of attribute scm_provider.



32
33
34
 
# File 'lib/chef/provider/deploy.rb', line 32

def scm_provider
  @scm_provider
end

Instance Method Details

#action_deploy ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/chef/provider/deploy.rb', line 96

def action_deploy
  save_release_state
  if deployed?(release_path )
    if current_release?(release_path ) 
      Chef::Log.debug("#{@new_resource} is the latest version")
    else
      rollback_to release_path
    end
  else

    with_rollback_on_error do
      deploy
    end
  end
end

#action_force_deploy ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/chef/provider/deploy.rb', line 112

def action_force_deploy
  if deployed?(release_path)
    converge_by("delete deployed app at #{release_path} prior to force-deploy") do 
      Chef::Log.info("Already deployed app at #{release_path}, forcing.")
      FileUtils.rm_rf(release_path)
      Chef::Log.info("#{@new_resource} forcing deploy of already deployed app at #{release_path}")
    end
  end

  # Alternatives:
  # * Move release_path directory before deploy and move it back when error occurs
  # * Rollback to previous commit
  # * Do nothing - because deploy is force, it will be retried in short time
  # Because last is simpliest, keep it
  deploy
end

#action_rollback ⇒ Object 



129
130
131
 
# File 'lib/chef/provider/deploy.rb', line 129

def action_rollback
  rollback_to all_releases[-2]
end

#all_releases ⇒ Object 



245
246
247
 
# File 'lib/chef/provider/deploy.rb', line 245

def all_releases
  Dir.glob(@new_resource.deploy_to + "/releases/*").sort
end

#callback(what, callback_code = nil) ⇒ Object 



182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/chef/provider/deploy.rb', line 182

def callback(what, callback_code=nil)
  @collection = Chef::ResourceCollection.new
  case callback_code
  when Proc
    Chef::Log.info "#{@new_resource} running callback #{what}"
    recipe_eval(&callback_code)
  when String
    run_callback_from_file("#{release_path}/#{callback_code}")
  when nil
    run_callback_from_file("#{release_path}/deploy/#{what}.rb")
  end
end

#cleanup! ⇒ Object 



234
235
236
237
238
239
240
241
242
243
 
# File 'lib/chef/provider/deploy.rb', line 234

def cleanup!
  chop = -1 - @new_resource.keep_releases
  all_releases[0..chop].each do |old_release|
    converge_by("remove old release #{old_release}") do
      Chef::Log.info "#{@new_resource} removing old release #{old_release}"
      FileUtils.rm_rf(old_release)
    end
    release_deleted(old_release)
  end
end

#copy_cached_repo ⇒ Object 



267
268
269
270
271
272
273
274
275
 
# File 'lib/chef/provider/deploy.rb', line 267

def copy_cached_repo
  target_dir_path = @new_resource.deploy_to + "/releases"
  converge_by("deploy from repo to #{@target_dir_path} ") do
    FileUtils.mkdir_p(target_dir_path)
    run_command(:command => "cp -RPp #{::File.join(@new_resource.destination, ".")} #{release_path}")
    Chef::Log.info "#{@new_resource} copied the cached checkout to #{release_path}"
    release_created(release_path)
  end
end

#create_dirs_before_symlink ⇒ Object 



340
341
 
# File 'lib/chef/provider/deploy.rb', line 340

def create_dirs_before_symlink
end

#define_resource_requirements ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/chef/provider/deploy.rb', line 71

def define_resource_requirements
  requirements.assert(:rollback) do |a|
    a.assertion { all_releases[-2] }
    a.failure_message(RuntimeError, "There is no release to rollback to!")
    #There is no reason to assume 2 deployments in a single chef run, hence fails in whyrun.
  end

  [ @new_resource.before_migrate, @new_resource.before_symlink, 
    @new_resource.before_restart, @new_resource.after_restart ].each do |script|
    requirements.assert(:deploy, :force_deploy) do |a|
      callback_file = "#{release_path}/#{script}"
      a.assertion do 
        if script && script.class == String
          ::File.exist?(callback_file)
        else
          true
        end
      end
      a.failure_message(RuntimeError, "Can't find your callback file #{callback_file}")
      a.whyrun("Would assume callback file #{callback_file} included in release")
    end
  end

end

#deploy ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/chef/provider/deploy.rb', line 150

def deploy
  verify_directories_exist
  # CHEF-3435: We need to create the directories if they don't exist before calling the
  # scm_provider because it expects them to be there in its own assertations
  unless self.converge_actions.empty?
    Chef::Log.info "#{@new_resource} running collected converge_actions before calling scm_provider"
    self.converge_actions.converge!
  end
  update_cached_repo # no converge-by - scm provider will dothis
  enforce_ownership
  copy_cached_repo
  install_gems
  enforce_ownership
  callback(:before_migrate, @new_resource.before_migrate)
  migrate
  callback(:before_symlink, @new_resource.before_symlink)
  symlink
  callback(:before_restart, @new_resource.before_restart)
  restart
  callback(:after_restart, @new_resource.after_restart)
  cleanup!
  Chef::Log.info "#{@new_resource} deployed to #{@new_resource.deploy_to}"
end

#enforce_ownership ⇒ Object 



277
278
279
280
281
282
283
 
# File 'lib/chef/provider/deploy.rb', line 277

def enforce_ownership
  converge_by("force ownership of #{@new_resource.deploy_to} to #{@new_resource.group}:#{@new_resource.user}") do
    FileUtils.chown_R(@new_resource.user, @new_resource.group, @new_resource.deploy_to)
    Chef::Log.info("#{@new_resource} set user to #{@new_resource.user}") if @new_resource.user
    Chef::Log.info("#{@new_resource} set group to #{@new_resource.group}") if @new_resource.group
  end
end

#link_current_release_to_production ⇒ Object 



290
291
292
293
294
295
296
297
298
299
300
301
302
 
# File 'lib/chef/provider/deploy.rb', line 290

def link_current_release_to_production
  converge_by(["remove existing link at #{@new_resource.current_path}", 
              "link release #{release_path} into production at #{@new_resource.current_path}"]) do
    FileUtils.rm_f(@new_resource.current_path)
    begin
      FileUtils.ln_sf(release_path, @new_resource.current_path)
      rescue => e
        raise Chef::Exceptions::FileNotFound.new("Cannot symlink current release to production: #{e.message}")
      end
    Chef::Log.info "#{@new_resource} linked release #{release_path} into production at #{@new_resource.current_path}"
  end
  enforce_ownership
end

#link_tempfiles_to_current_release ⇒ Object 



318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/chef/provider/deploy.rb', line 318

def link_tempfiles_to_current_release
  dirs_info = @new_resource.create_dirs_before_symlink.join(",")
  @new_resource.create_dirs_before_symlink.each do |dir| 
    create_dir_unless_exists(release_path + "/#{dir}")
  end
  Chef::Log.info("#{@new_resource} created directories before symlinking: #{dirs_info}")

  links_info = @new_resource.symlinks.map { |src, dst| "#{src} => #{dst}" }.join(", ")
  converge_by("link shared paths into current release:  #{links_info}") do
    @new_resource.symlinks.each do |src, dest|
      begin
        FileUtils.ln_sf(::File.join(@new_resource.shared_path, src), ::File.join(release_path, dest))
      rescue => e
        raise Chef::Exceptions::FileNotFound.new("Cannot symlink shared data #{::File.join(@new_resource.shared_path, src)} to #{::File.join(release_path, dest)}: #{e.message}")
      end
    end
    Chef::Log.info("#{@new_resource} linked shared paths into current release: #{links_info}")
  end
  run_symlinks_before_migrate
  enforce_ownership
end

#load_current_resource ⇒ Object 



51
52
53
54
 
# File 'lib/chef/provider/deploy.rb', line 51

def load_current_resource
  @scm_provider.load_current_resource
  @release_path = @new_resource.deploy_to + "/releases/#{release_slug}"
end

#migrate ⇒ Object 



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/chef/provider/deploy.rb', line 195

def migrate
  run_symlinks_before_migrate

  if @new_resource.migrate
    enforce_ownership

    environment = @new_resource.environment
    env_info = environment && environment.map do |key_and_val|
      "#{key_and_val.first}='#{key_and_val.last}'"
    end.join(" ")

    converge_by("execute migration command #{@new_resource.migration_command}") do
      Chef::Log.info "#{@new_resource} migrating #{@new_resource.user} with environment #{env_info}"
      run_command(run_options(:command => @new_resource.migration_command, :cwd=>release_path, :log_level => :info))
    end
  end
end

#purge_tempfiles_from_current_release ⇒ Object 



343
344
345
346
347
348
349
 
# File 'lib/chef/provider/deploy.rb', line 343

def purge_tempfiles_from_current_release
  log_info = @new_resource.purge_before_symlink.join(", ")
  converge_by("purge directories in checkout #{log_info}") do
    @new_resource.purge_before_symlink.each { |dir| FileUtils.rm_rf(release_path + "/#{dir}") }
    Chef::Log.info("#{@new_resource} purged directories in checkout #{log_info}")
  end
end

#restart ⇒ Object 



220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/chef/provider/deploy.rb', line 220

def restart
  if restart_cmd = @new_resource.restart_command
    if restart_cmd.kind_of?(Proc)
      Chef::Log.info("#{@new_resource} restarting app with embedded recipe")
      recipe_eval(&restart_cmd)
    else
      converge_by("restart app using command #{@new_resource.restart_command}") do
        Chef::Log.info("#{@new_resource} restarting app")
        run_command(run_options(:command => @new_resource.restart_command, :cwd => @new_resource.current_path))
      end
    end
  end
end

#rollback ⇒ Object 



174
175
176
177
178
179
 
# File 'lib/chef/provider/deploy.rb', line 174

def rollback
  Chef::Log.info "#{@new_resource} rolling back to previous release #{release_path}"
  symlink
  Chef::Log.info "#{@new_resource} restarting with previous release"
  restart
end

#rollback_to(target_release_path) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/chef/provider/deploy.rb', line 133

def rollback_to(target_release_path)
  @release_path = target_release_path

  rp_index = all_releases.index(release_path)
  releases_to_nuke = all_releases[(rp_index + 1)..-1]

  rollback

  releases_to_nuke.each do |i|
    converge_by("roll back by removing release #{i}") do
      Chef::Log.info "#{@new_resource} removing release: #{i}"
      FileUtils.rm_rf i
    end
    release_deleted(i)
  end
end

#run(command, &block) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
 
# File 'lib/chef/provider/deploy.rb', line 60

def run(command, &block)
  exec = execute(command, &block)
  exec.user(@new_resource.user) if @new_resource.user
  exec.group(@new_resource.group) if @new_resource.group
  exec.cwd(release_path) unless exec.cwd
  exec.environment(@new_resource.environment) unless exec.environment
  converge_by("execute #{command}") do
    exec
  end
end

#run_scm_sync ⇒ Object 



258
259
260
 
# File 'lib/chef/provider/deploy.rb', line 258

def run_scm_sync
  @scm_provider.run_action(:sync)
end

#run_symlinks_before_migrate ⇒ Object 



304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File 'lib/chef/provider/deploy.rb', line 304

def run_symlinks_before_migrate
  links_info = @new_resource.symlink_before_migrate.map { |src, dst| "#{src} => #{dst}" }.join(", ")
  converge_by("make pre-migration symliinks: #{links_info}") do
    @new_resource.symlink_before_migrate.each do |src, dest|
      begin
        FileUtils.ln_sf(@new_resource.shared_path + "/#{src}", release_path + "/#{dest}")
      rescue => e
        raise Chef::Exceptions::FileNotFound.new("Cannot symlink #{@new_resource.shared_path}/#{src} to #{release_path}/#{dest} before migrate: #{e.message}")
      end
    end
    Chef::Log.info "#{@new_resource} made pre-migration symlinks"
  end
end

#sudo(command, &block) ⇒ Object 



56
57
58
 
# File 'lib/chef/provider/deploy.rb', line 56

def sudo(command,&block)
  execute(command, &block)
end

#svn_force_export ⇒ Object 



262
263
264
265
 
# File 'lib/chef/provider/deploy.rb', line 262

def svn_force_export
  Chef::Log.info "#{@new_resource} exporting source repository"
  @scm_provider.run_action(:force_export)
end

#symlink ⇒ Object 



213
214
215
216
217
218
 
# File 'lib/chef/provider/deploy.rb', line 213

def symlink
  purge_tempfiles_from_current_release
  link_tempfiles_to_current_release
  link_current_release_to_production
  Chef::Log.info "#{@new_resource} updated symlinks"
end

#update_cached_repo ⇒ Object 



249
250
251
252
253
254
255
256
 
# File 'lib/chef/provider/deploy.rb', line 249

def update_cached_repo
  if @new_resource.svn_force_export
  # TODO assertion, non-recoverable - @scm_provider must be svn if force_export?
    svn_force_export
  else
    run_scm_sync
  end
end

#verify_directories_exist ⇒ Object 



285
286
287
288
 
# File 'lib/chef/provider/deploy.rb', line 285

def verify_directories_exist
  create_dir_unless_exists(@new_resource.deploy_to)
  create_dir_unless_exists(@new_resource.shared_path)
end

#whyrun_supported? ⇒ Boolean

Returns:

  • (Boolean) 


47
48
49
 
# File 'lib/chef/provider/deploy.rb', line 47

def whyrun_supported?
  true
end