Parent

Included Modules

OpenShift::CartridgeRepository

Singleton to provide management of cartridges installed on the system

Constants

CARTRIDGE_REPO_DIR

FIXME: move to node.conf

Attributes

path[R]

Filesystem path to where cartridges are installed

Public Class Methods

instantiate_cartridge(cartridge, path) → nil click to toggle source

Instantiate a cartridge in a gear;

If the cartridge manifest_path is :url then source_url is used to obtain cartridge source
Otherwise the cartridge source is copied from the cartridge_repository

source_hash is used to ensure the download was successful.

CartridgeRepository.instantiate_cartridge(perl_cartridge, '/var/lib/.../mock') => nil
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 358
def self.instantiate_cartridge(cartridge, target, failure_remove = true)
  FileUtils.mkpath target

  if :url == cartridge.manifest_path
    uri       = URI(cartridge.source_url)
    temporary = PathUtils.join(File.dirname(target), File.basename(cartridge.source_url))
    cartridge.validate_vendor_name
    cartridge.check_reserved_vendor_name
    cartridge.validate_cartridge_name

    case
      when 'git' == uri.scheme || cartridge.source_url.end_with?('.git')
        Utils::oo_spawn(%(set -xe;
                           git clone #{cartridge.source_url} #{cartridge.name};
                           GIT_DIR=./#{cartridge.name}/.git git repack),
                        chdir:               Pathname.new(target).parent.to_path,
                        expected_exitstatus: 0)

      when uri.scheme =~ /^https*/ && cartridge.source_url =~ /\.zip/
        begin
          uri_copy(URI(cartridge.source_url), temporary, cartridge.source_md5)
          extract(:zip, temporary, target)
        ensure
          FileUtils.rm(temporary)
        end

      when uri.scheme =~ /^https*/ && cartridge.source_url =~ /(\.tar\.gz|\.tgz)$/
        begin
          uri_copy(URI(cartridge.source_url), temporary, cartridge.source_md5)
          extract(:tgz, temporary, target)
        ensure
          FileUtils.rm(temporary)
        end

      when uri.scheme =~ /^https*/ && cartridge.source_url =~ /\.tar$/
        begin
          uri_copy(URI(cartridge.source_url), temporary, cartridge.source_md5)
          extract(:tar, temporary, target)
        ensure
          FileUtils.rm(temporary)
        end

      when 'file' == uri.scheme
        entries = Dir.glob(PathUtils.join(uri.path, '*'), File::FNM_DOTMATCH)
        filesystem_copy(entries, target, %(. ..))

      else
        raise ArgumentError.new("CLIENT_ERROR: Unsupported URL(#{cartridge.source_url}) for downloading a private cartridge")
    end
  else
    entries = Dir.glob(PathUtils.join(cartridge.repository_path, '*'), File::FNM_DOTMATCH)
    filesystem_copy(entries, target, %(. .. usr))

    source_usr = File.join(cartridge.repository_path, 'usr')
    target_usr = File.join(target, 'usr')

    FileUtils.rm(target_usr) if File.symlink?(target_usr)
    FileUtils.symlink(source_usr, target_usr) if File.exist?(source_usr) && !File.exist?(target_usr)
  end

  valid_cartridge_home(cartridge, target)
rescue => e
  FileUtils.rm_rf target if failure_remove
  raise e
end
overlay_cartridge(cartridge, path) → nil click to toggle source

Overlay new code over existing cartridge in a gear;

If the cartridge manifest_path is :url then source_url is used to obtain cartridge source
Otherwise the cartridge source is copied from the cartridge_repository

source_hash is used to ensure the download was successful.

CartridgeRepository.overlay_cartridge(perl_cartridge, '/var/lib/.../mock') => nil
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 344
def self.overlay_cartridge(cartridge, target)
  instantiate_cartridge(cartridge, target, false)
end

Public Instance Methods

[](cartridge_name, version = '_', cartridge_version = "_") click to toggle source
Alias for: select
instance.clear → nil click to toggle source

Clear all entries from the memory index. Nothing is removed from the disk.

CartridgeRepository.instance.clear #=> nil
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 105
def clear
  @index = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
end
instance.each → Cartridge click to toggle source

Process each unique cartridge

CartridgeRepository.instance.each {|c| puts c.name}
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 284
def each
  return to_enum(:each) unless block_given?

  cartridges = Set.new
  @index.each_pair do |_, sw_hash|
    sw_hash.each_pair do |_, cart_hash|
      cart_hash.each_pair do |_, cartridge|
        cartridges.add(cartridge)
      end
    end
  end

  cartridges.each { |c| yield c }
  self
end
instance.erase(cartridge_name, version, cartridge_version) → Cartridge click to toggle source

Erase given version of a cartridge from the cartridge repository and remove from index. This cannot be undone.

CartridgeRepository.instance.erase('php', '3.5', '1.0') #=> Cartridge
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 197
def erase(cartridge_name, version, cartridge_version)
  unless exist?(cartridge_name, cartridge_version, version)
    raise KeyError.new("key not found: (#{cartridge_name}, #{version}, #{cartridge_version})")
  end

  entry = nil
  $OpenShift_CartridgeRepository_SEMAPHORE.synchronize do
    # find a "template" entry
    entry = select(cartridge_name, version, cartridge_version)

    # Now go back and find all occurrences of the "template"
    @index[cartridge_name].each_key do |k2|
      @index[cartridge_name][k2].each_pair do |k3, v3|
        if v3.eql?(entry)
          remove(cartridge_name, k2, k3)
        end
      end
    end

    FileUtils.rm_r(entry.repository_path)
    parent = Pathname.new(entry.repository_path).parent
    FileUtils.rm_r(parent) if 0 == parent.children.count
  end

  entry
end
instance.exists?(cartridge_name, cartridge_version, version) → true or false click to toggle source

Is there an entry in the repository for this tuple?

CartridgeRepository.instance.erase('cobol', '2002', '1.0') #=> false
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 230
def exist?(cartridge_name, cartridge_version, version)
  @index.key?(cartridge_name) &&
      @index[cartridge_name].key?(version) &&
      @index[cartridge_name][version].key?(cartridge_version)
end
inspect() click to toggle source

print out all index entries in a table

# File lib/openshift-origin-node/model/cartridge_repository.rb, line 317
def inspect
  @index.inject("<CartridgeRepository:\n") do |memo, (name, sw_hash)|
    sw_hash.inject(memo) do |memo, (sw_ver, cart_hash)|
      cart_hash.inject(memo) do |memo, (cart_ver, cartridge)|
        memo << "(#{name}, #{sw_ver}, #{cart_ver}): " << cartridge.to_s << "\n"
      end
    end
  end << '>'
end
instance.install(directory) → Cartridge click to toggle source

Copies a cartridge's source into the cartridge repository from a directory. The Cartridge will additionally be indexed and available from a CartridgeRepository.instance

CartridgeRepository.instance.install('/usr/libexec/openshift/v2/cartridges/openshift-origin-php')  #=> Cartridge
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 171
def install(directory)
  raise ArgumentError.new("Illegal path to cartridge source: '#{directory}'") unless directory && File.directory?(directory)
  raise ArgumentError.new("Source cannot be: '#{@path}'") if directory == @path

  manifest_path = PathUtils.join(directory, 'metadata', 'manifest.yml')
  raise ArgumentError.new("Cartridge manifest.yml missing: '#{manifest_path}'") unless File.file?(manifest_path)

  entry = nil
  $OpenShift_CartridgeRepository_SEMAPHORE.synchronize do
    entry = insert(OpenShift::Runtime::Manifest.new(manifest_path, nil, @path))

    FileUtils.rm_r(entry.repository_path) if File.exist?(entry.repository_path)
    FileUtils.mkpath(entry.repository_path)

    Utils.oo_spawn("shopt -s dotglob; /bin/cp -ad #{directory}/* #{entry.repository_path}",
                   expected_exitstatus: 0)
  end
  entry
end
latest_versions() click to toggle source
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 300
def latest_versions
  cartridges = Set.new
  @index.each_pair do |_, sw_hash|
    sw_hash.each_pair do |_, cart_version_hash|
      latest_version = cart_version_hash.keys.sort.last
      cartridges.add(cart_version_hash[latest_version])
    end
  end

  if block_given?
    cartridges.each { |c| yield c }
  end

  cartridges
end
instance.load([directory path]) → Fixnum click to toggle source

Read cartridge manifests from the CARTRIDGE_REPO_DIR or the provided directory.

CartridgeRepository.instance.load("/var/lib/openshift/.cartridge_repository")  #=> 24
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 115
def load(directory = nil)
  $OpenShift_CartridgeRepository_SEMAPHORE.synchronize do
    load_via_url = directory.nil?
    find_manifests(directory || @path) do |manifest_path|
      logger.debug { "Loading cartridge from #{manifest_path}" }
      # we check the vendor and cartridge names only when loading via URL
      c = insert(OpenShift::Runtime::Manifest.new(manifest_path, nil, @path, load_via_url))
      logger.debug { "Loaded cartridge (#{c.name}, #{c.version}, #{c.cartridge_version})" }
    end
  end

  count
end
instance.select(cartridge_name) → Cartridge click to toggle source
instance.select(cartridge_name, version) → Cartridge
instance.select(cartridge_name, version, cartridge_version) → Cartridge
instance[cartridge_name] → Cartridge
instance[cartridge_name, version] → Cartridge
instance[cartridge_name, version, cartridge_version] → Cartridge

Select a cartridge from repository

Each version parameter you provide narrows the search to the exact revision of the Cartridge you are requesting. If you do not provide cartridge_version then the latest is assumed, for version and cartridge_name. If you do not provide cartridge_version and version, then the latest cartridge_name will be returned.

Latest is determined from the Version elements provided in the cartridge's manifest, when the cartridge is loaded.

Assuming PHP, 3.5 and 0.1 are all the latest each of these calls would return the same cartridge.

CartridgeRepository.instance.select('php', '3.5', '0.1')  #=> Cartridge
CartridgeRepository.instance.select('php', '3.5')         #=> Cartridge
CartridgeRepository.instance.select('php')                #=> Cartridge
CartridgeRepository.instance['php', '3.5', '0.1']         #=> Cartridge
CartridgeRepository.instance['php', '3.5']                #=> Cartridge
CartridgeRepository.instance['php']                       #=> Cartridge
# File lib/openshift-origin-node/model/cartridge_repository.rb, line 154
def select(cartridge_name, version = '_', cartridge_version = "_")
  unless exist?(cartridge_name, cartridge_version, version)
    raise KeyError.new("key not found: (#{cartridge_name}, #{version}, #{cartridge_version})")
  end

  @index[cartridge_name][version][cartridge_version]
end
Also aliased as: []
to_s() click to toggle source

print out all indexed cartridges in a table

# File lib/openshift-origin-node/model/cartridge_repository.rb, line 328
def to_s
  each_with_object("") do |c, memo|
    memo << "(#{c.cartridge_vendor}, #{c.name}, #{c.version}, #{c.cartridge_version})\n"
  end
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.