Class/Module Index [+]

Quicksearch

OpenShift::Runtime::ApplicationContainerExt::Deployments

Public Instance Methods

all_deployments() click to toggle source

Returns all the deployment directories, in no particular order

# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 21
def all_deployments
  deployments_dir = PathUtils.join(@container_dir, 'app-deployments')

  Dir[deployments_dir + "/*"].entries.reject { |e| %(by-id current).include?(File.basename(e)) }
end
all_deployments_by_activation(dirs = nil) click to toggle source

Returns all the date/time based deployment directories (full paths), sorted by most recent activation date/time in ascending order (i.e. oldest activation first)

# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 30
def all_deployments_by_activation(dirs = nil)
  deployments = dirs || all_deployments
  count = 0

  # need to call sort before sort_by so the dirs are sorted by name (creation datetime)
  # otherwise sorting by (Float::MAX - count) might be in the wrong order, which can
  # result in prune_deployments deleting the wrong dir!
  deployments.sort.sort_by do |d|
    latest_activation = deployment_metadata_for(File.basename(d)).activations.last

    # treat a deployment dir without any activations as the latest
    # TODO may want to revisit this later, but it allows prune to work by considering
    # dirs with no activations as newer than any other dir, so we can delete a dir
    # that actually has at least 1 activation
    count += 1
    latest_activation || (Float::MAX - count)
  end
end
archive(deployment_datetime = nil) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 334
def archive(deployment_datetime = nil)
  deployment_datetime ||= current_deployment_datetime
  deployment_dir = PathUtils.join(@container_dir, 'app-deployments', deployment_datetime)
  command = "tar zcf - --exclude metadata.json ."
  out, err, rc = run_in_container_context(command,
                                          chdir: deployment_dir,
                                          expected_exitstatus: 0,
                                          out: $stdout,
                                          err: $stderr)
  out
end
calculate_deployment_checksum(deployment_id) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 193
def calculate_deployment_checksum(deployment_id)
  deployment_dir = PathUtils.join(@container_dir, 'app-deployments', 'by-id', deployment_id)

  command = "tar -c --exclude metadata.json . | tar -xO | sha1sum | cut -f 1 -d ' '"

  out, err, rc = run_in_container_context(command,
                                          chdir: deployment_dir,
                                          expected_exitstatus: 0)

  out.chomp
end
calculate_deployment_id(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 189
def calculate_deployment_id(deployment_datetime)
  SecureRandom.hex(4)
end
calculate_deployments() click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 346
def calculate_deployments
  deployments = []
  all_deployments.each do |d|
    deployment_datetime = File.basename(d)
    deployment_metadata = deployment_metadata_for(deployment_datetime)
    deployments.push({
      :id => deployment_metadata.id,
      :ref => deployment_metadata.git_ref,
      :sha1 => deployment_metadata.git_sha1,
      :force_clean_build => deployment_metadata.force_clean_build,
      :hot_deploy => deployment_metadata.hot_deploy,
      :created_at => Time.strptime(deployment_datetime, DEPLOYMENT_DATETIME_FORMAT).to_f,
      :activations => deployment_metadata.activations
    })
  end
  deployments
end
check_deployments_integrity(options = {}) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 113
def check_deployments_integrity(options = {})
  buffer = ''
  FileUtils.mkdir_p(PathUtils.join(@container_dir, 'app-deployments', 'by-id'))

  deployments = all_deployments.map { | x | File.basename(x) }

  linked_deployments = Dir.glob(PathUtils.join(@container_dir, 'app-deployments', 'by-id', '*')).map do | link |
    File.basename(File.readlink(link))
  end

  unlinked_deployments = deployments - linked_deployments

  if !unlinked_deployments.empty?
    message = "Repairing links for #{unlinked_deployments.size} deployments"
    options[:out].puts message if options[:out]
    buffer << message
  end

  unlinked_deployments.each do | deployment_datetime |
    deployment_id = calculate_deployment_id(deployment_datetime)
    deployment_metadata = deployment_metadata_for(deployment_datetime)
    deployment_metadata.id = deployment_id
    deployment_metadata.save

    link_deployment_id(deployment_datetime, deployment_id)
  end

  set_rw_permission_R(PathUtils.join(@container_dir, 'app-deployments'))

  unless current_deployment_datetime
    all_deployments_by_activation.reverse.each do |deployment|
      deployment_datetime = File.basename(deployment)
      deployment_metadata = deployment_metadata_for(deployment_datetime)

      if deployment_metadata.activations.empty?
        next
      end

      message = "Repairing current deployment symlink: #{deployment_datetime}"
      options[:out].puts message if options[:out]
      buffer << message

      update_current_deployment_datetime_symlink(deployment_datetime)
      break
    end
  end

  buffer
end
clean_runtime_dirs(options) click to toggle source

Removes all files from app-root/runtime/<dirs>

options for dirs to delete (all default to false):

:dependencies
:build_dependencies
:repo
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 89
def clean_runtime_dirs(options)
  dirs = []
  %(dependencies build_dependencies repo).each do |dir|
    dirs << dir if options[dir.to_sym] == true
  end

  return if dirs.empty?

  dirs.map! { |dir| "app-root/runtime/#{dir.gsub(/_/, '-')}/*" }

  out, err, rc = run_in_container_context("shopt -s dotglob; rm -rf #{dirs.join(' ')}",
                                            chdir: @container_dir,
                                            expected_exitstatus: 0)
end
copy_dependencies(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 69
def copy_dependencies(deployment_datetime)
  # FileUtils.cp_r balks when using preserve:true when trying to update the metadata
  # for a symlink that points to a file that hasn't yet been copied over - resorting
  # to shelling out to "cp -a" instead
  out, err, rc = run_in_container_context("/bin/cp -a app-root/runtime/dependencies/. app-deployments/#{deployment_datetime}/dependencies",
                                          chdir: @container_dir,
                                          expected_exitstatus: 0)

  out, err, rc = run_in_container_context("/bin/cp -a app-root/runtime/build-dependencies/. app-deployments/#{deployment_datetime}/build-dependencies",
                                          chdir: @container_dir,
                                          expected_exitstatus: 0)

end
create_deployment_dir() click to toggle source

Creates a deployment directory in app-root/deployments with a name like 2013-07-19_09-37-03.431

returns the name of the newly created directory (just the date and time, not the full path)

# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 174
def create_deployment_dir()
  deployment_datetime = Time.now.strftime(DEPLOYMENT_DATETIME_FORMAT)
  full_path = PathUtils.join(@container_dir, 'app-deployments', deployment_datetime)
  FileUtils.mkdir_p(full_path)
  FileUtils.mkdir_p(PathUtils.join(full_path, "repo"))
  FileUtils.mkdir_p(PathUtils.join(full_path, "dependencies"))
  FileUtils.mkdir_p(PathUtils.join(full_path, "build-dependencies"))
  FileUtils.chmod_R(0o0750, full_path, :verbose => @debug)
  set_rw_permission_R(full_path)

  prune_deployments

  deployment_datetime
end
current_deployment_datetime() click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 104
def current_deployment_datetime
  file = PathUtils.join(@container_dir, 'app-deployments', 'current')
  if File.exist?(file)
    File.readlink(file)
  else
    nil
  end
end
delete_activations_before(cutoff) click to toggle source

Removes all activation entries from all deployment directories where the activation time <= cutoff

@param [Float] cutoff activation cutoff time

# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 319
def delete_activations_before(cutoff)
  all_deployments.each do |full_path|
    deployment_datetime = File.basename(full_path)

    # load the metadata
    deployment_metadata = deployment_metadata_for(deployment_datetime)

    # remove activations <= cutoff
    deployment_metadata.activations.delete_if { |a| a <= cutoff }

    # write metadata to disk
    deployment_metadata.save
  end
end
delete_deployment(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 266
def delete_deployment(deployment_datetime)
  deployments_dir = PathUtils.join(@container_dir, 'app-deployments')
  deployment_id = deployment_metadata_for(deployment_datetime).id
  FileUtils.rm_f(PathUtils.join(deployments_dir, 'by-id', deployment_id)) if deployment_id
  FileUtils.rm_rf(PathUtils.join(deployments_dir, deployment_datetime))
end
deployment_exists?(deployment_id) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 55
def deployment_exists?(deployment_id)
  File.exist?(PathUtils.join(@container_dir, 'app-deployments', 'by-id', deployment_id))
end
deployment_metadata_for(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 11
def deployment_metadata_for(deployment_datetime)
  ::OpenShift::Runtime::DeploymentMetadata.new(self, deployment_datetime)
end
deployments_to_keep(env) click to toggle source

Returns the number of deployments to keep as configured in the given env

# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 16
def deployments_to_keep(env)
  (env['OPENSHIFT_KEEP_DEPLOYMENTS'] || 1).to_i
end
determine_extract_command(options) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 401
def determine_extract_command(options)
  use_artifact_url  = !!options[:artifact_url]
  use_stdin         = !!options[:stdin]
  filename          = options[:file]

  if use_artifact_url
    "/usr/bin/curl #{options[:artifact_url]} | /bin/tar -xz"
  elsif use_stdin
    "/bin/tar -xz"
  elsif filename =~ /\.tar\.gz$/ or filename =~ /\.tar$/
    "/bin/tar xf #{filename}"
  elsif filename =~ /\.zip$/
    "/usr/bin/unzip -q #{filename}"
  else
    raise "Unable to determine file type for '#{filename}' - unable to deploy"
  end
end
extract_deployment_archive(env, options = {}) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 419
def extract_deployment_archive(env, options = {})
  file        = options[:file]
  destination = options[:destination]

  if destination.nil?
    raise "Destination must be supplied"
  end

  if file && !File.exist?(file)
    raise "Specified file '#{file}' does not exist."
  end

  extract_command = determine_extract_command(options)

  # explode file
  out, err, rc = run_in_container_context(extract_command,
                                          in: options[:stdin],
                                          out: $stderr,
                                          err: $stderr,
                                          env: env,
                                          chdir: destination,
                                          expected_exitstatus: 0)
end
get_deployment_datetime_for_deployment_id(deployment_id) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 216
def get_deployment_datetime_for_deployment_id(deployment_id)
  return nil unless deployment_exists?(deployment_id)

  # read the symlink - will be something like ../2013-07-24_16-41-55
  deployment_dir_link = File.readlink(PathUtils.join(@container_dir, 'app-deployments', 'by-id', deployment_id))
  # return just the date/time portion
  File.basename(deployment_dir_link)
end
latest_deployment_datetime() click to toggle source

Returns the most recent date/time based deployment directory name

# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 50
def latest_deployment_datetime
  latest = all_deployments_by_activation[-1]
  File.basename(latest)
end
list_deployments() click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 381
def list_deployments
  current = current_deployment_datetime

  list = []
  list << "Activation time - Deployment ID - Git Ref - Git SHA1"
  list += all_deployments_by_activation.reverse.map do |d|
    deployment_datetime = File.basename(d)
    deployment_metadata = deployment_metadata_for(deployment_datetime)
    active_text = " - ACTIVE" if deployment_datetime == current
    latest_activation = deployment_metadata.activations.last
    activation_text = if latest_activation.nil?
      'NEVER'
    else
      Time.at(latest_activation)
    end
    "#{activation_text} - #{deployment_metadata.id} - #{deployment_metadata.git_ref} - #{deployment_metadata.git_sha1}#{active_text}"
  end
  list.join("\n")
end
move_dependencies(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 59
def move_dependencies(deployment_datetime)
  # move the dependencies from the previous deployment to the one we're about to build
  out, err, rc = run_in_container_context("set -x; shopt -s dotglob; /bin/mv app-root/runtime/dependencies/* app-deployments/#{deployment_datetime}/dependencies",
                                          chdir: @container_dir)
  # rc may be nonzero if the current dependencies dir is empty

  out, err, rc = run_in_container_context("set -x; shopt -s dotglob; /bin/mv app-root/runtime/build-dependencies/* app-deployments/#{deployment_datetime}/build-dependencies",
                                          chdir: @container_dir)
end
prune_deployments() click to toggle source

Prunes deployment directories, using the following algorithm:

  • Only keep at most $OPENSHIFT_KEEP_DEPLOYMENTS directories in app-deployments

  • Remove the "oldest" directory sorted by latest activation time

  • Also remove any activation times earlier than the latest activation time of the deployment being deleted across all deployments

# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 281
def prune_deployments
  gear_env = ::OpenShift::Runtime::Utils::Environ.for_gear(@container_dir)
  to_keep = deployments_to_keep(gear_env)
  deleted = 0

  deployments = all_deployments

  # short-circuit - don't do anything if we're under the limit
  count = deployments.count
  return if count <= to_keep

  # remove so we stay under to_keep
  all = all_deployments_by_activation(deployments)

  # this is the activation time of the most recent deployment to be deleted
  activation_cutoff = nil

  all.each do |d|
    # stop if the remaining # of deployments is <= to_keep
    break if count <= to_keep

    deployment_datetime = File.basename(d)

    activation_cutoff = deployment_metadata_for(deployment_datetime).activations.last

    delete_deployment(deployment_datetime)

    # update remaining # of deployments
    count -= 1
  end

  delete_activations_before(activation_cutoff) unless activation_cutoff.nil?
end
set_auto_deploy(auto_deploy) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 373
def set_auto_deploy(auto_deploy)
  add_env_var('AUTO_DEPLOY', auto_deploy, true)
end
set_deployment_branch(deployment_branch) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 369
def set_deployment_branch(deployment_branch)
  add_env_var('DEPLOYMENT_BRANCH', deployment_branch, true)
end
set_deployment_type(deployment_type) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 377
def set_deployment_type(deployment_type)
  add_env_var('DEPLOYMENT_TYPE', deployment_type, true)
end
set_keep_deployments(keep_deployments) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 364
def set_keep_deployments(keep_deployments)
  add_env_var('KEEP_DEPLOYMENTS', keep_deployments, true)
  #TODO Clean up any deployments over the limit
end
sync_deployment_build_dependencies_dir_to_runtime(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 244
def sync_deployment_build_dependencies_dir_to_runtime(deployment_datetime)
  sync_deployment_dir_to_runtime(deployment_datetime, 'build-dependencies')
end
sync_deployment_dependencies_dir_to_runtime(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 240
def sync_deployment_dependencies_dir_to_runtime(deployment_datetime)
  sync_deployment_dir_to_runtime(deployment_datetime, 'dependencies')
end
sync_deployment_dir_to_runtime(deployment_datetime, name) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 230
def sync_deployment_dir_to_runtime(deployment_datetime, name)
  from = PathUtils.join(@container_dir, 'app-deployments', deployment_datetime, name)
  to = PathUtils.join(@container_dir, 'app-root', 'runtime', name)
  sync_files(from, to)
end
sync_deployment_repo_dir_to_runtime(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 236
def sync_deployment_repo_dir_to_runtime(deployment_datetime)
  sync_deployment_dir_to_runtime(deployment_datetime, 'repo')
end
sync_files(from, to) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 225
def sync_files(from, to)
  out, err, rc = run_in_container_context("/usr/bin/rsync -av --delete #{from}/ #{to}/",
                                          expected_exitstatus: 0)
end
sync_runtime_build_dependencies_dir_to_deployment(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 262
def sync_runtime_build_dependencies_dir_to_deployment(deployment_datetime)
  sync_runtime_dir_to_deployment(deployment_datetime, 'build-dependencies')
end
sync_runtime_dependencies_dir_to_deployment(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 258
def sync_runtime_dependencies_dir_to_deployment(deployment_datetime)
  sync_runtime_dir_to_deployment(deployment_datetime, 'dependencies')
end
sync_runtime_dir_to_deployment(deployment_datetime, name) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 248
def sync_runtime_dir_to_deployment(deployment_datetime, name)
  from = PathUtils.join(@container_dir, 'app-root', 'runtime', name)
  to = PathUtils.join(@container_dir, 'app-deployments', deployment_datetime, name)
  sync_files(from, to)
end
sync_runtime_repo_dir_to_deployment(deployment_datetime) click to toggle source
# File lib/openshift-origin-node/model/application_container_ext/deployments.rb, line 254
def sync_runtime_repo_dir_to_deployment(deployment_datetime)
  sync_runtime_dir_to_deployment(deployment_datetime, 'repo')
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.