Commit ffeefb9

$stdout.sync = true

$stderr.sync = true

$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)

require 'java_buildpack/buildpack'

app_dir = ARGV[0]

JavaBuildpack::Buildpack.with_buildpack(app_dir, 'Finalize failed with exception %s', &:compile)

- "JavaBuildpack::Framework::MultiBuildpack"

The Multiple Buildpack Framework enables the Java Buildpack to act as the final buildpack in a multiple buildpack deployment. It reads the contributions of other, earlier buildpacks and incorporates them into its standard staging.

The Java Options Framework contributes arbitrary Java options to the application at runtime.

<table>

<tr>

<td><strong>Detection Criterion</strong></td>

<td>Existence of buildpack contribution directories (typically <tt>/tmp/&lt;RANDOM&gt;/deps/&lt;INDEX&gt;</tt> containing a <tt>config.yml</tt> file.</td>

</tr>

<tr>

<td><strong>Tags</strong></td>

<td><tt>multi-buildpack=&lt;BUILDPACK_NAME&gt;,...</tt></td>

</tr>

</table>

Tags are printed to standard output by the buildpack detect script

When the Java Buildpack acts as the final buildpack in a multiple buildpack deployment it honors the following core contract integration points.

| Integration Point | Buildpack Usage

| ----------------- | ---------------

| `/bin` | An existing `/bin` directory contributed by a non-final buildpack will be added to the `$PATH` of the application as it executes

| `/lib` | An existing `/lib` directory contributed by a non-final buildpack will be added to the `$LD_LIBRARY_PATH` of the application as it executes

In addition to the core contract, the Java Buildpack defines the following keys in `config.yml` as extension points for contributing to the application. **All keys are optional, and all paths are absolute.**

| Key | Type | Description

| --- | ---- | -----------

| `additional_libraries` | `[ path ]` | An array of absolute paths to libraries will be added to the application's classpath

| `environment_variables` | `{ string, ( path \| string ) }` | A hash of string keys to absolute path or string values that will be added as environment variables

| `extension_directories` | `[ path ]` | An array of absolute paths to directories containing JRE extensions

| `java_opts.agentpaths` | `[ path ]` | An array of absolute paths to libraries that will be added as agents

| `java_opts.agentpaths_with_props` | `{ path, { string, string } }` | A nested hash with absolute paths keys and hashes of string keys and string values as a value that will be added as agents with properties

| `java_opts.bootclasspath_ps` | `[ path ]` | An array of absolute paths that will be added to the application's bootclasspath

| `java_opts.javaagents` | `[ path ]` | An array of absolute paths that will be added as javaagents

| `java_opts.preformatted_options` | `[ string ]` | An array of strings that will be added as options without modification

| `java_opts.options` | `{ string, ( path \| string ) }` | A hash of string keys to absolute path or string values that will be added as options

| `java_opts.system_properties` | `{ string , ( path \| string ) }` | A hash of string keys to absolute path or string values that will be added as system properties

| `security_providers` | `[ string ]` | An array of strings to be added to list of security providers

require 'fileutils'

require 'pathname'

require 'java_buildpack/component/base_component'

require 'java_buildpack/framework'

require 'java_buildpack/logging/logger_factory'

require 'java_buildpack/util/qualify_path'

require 'yaml'

module JavaBuildpack

module Framework

# Encapsulates the functionality for multi buildpack support.

class MultiBuildpack < JavaBuildpack::Component::BaseComponent

include JavaBuildpack::Util

# (see JavaBuildpack::Component::BaseComponent#initialize)

def initialize(context)

super(context)

@logger = JavaBuildpack::Logging::LoggerFactory.instance.get_logger MultiBuildpack

@logger.debug { "Dependencies Directory: #{ARGV[3]}" }

end

# (see JavaBuildpack::Component::BaseComponent#detect)

def detect

!dep_directories.empty? ? "multi-buildpack=#{names(dep_directories).join(',')}" : nil

end

# (see JavaBuildpack::Component::BaseComponent#compile)

def compile

puts "#{'----->'.red.bold} #{'Multiple Buildpacks'.blue.bold} detected"

dep_directories.each do |dep_directory|

config = config(config_file(dep_directory))

name = name(config)

log_configuration config

log_dep_contents dep_directory

contributions = [

add_bin(dep_directory),

add_lib(dep_directory),

add_additional_libraries(config),

add_environment_variables(config),

add_extension_directories(config),

add_java_opts(config),

add_security_providers(config)

]

puts " #{name}#{contributions_message(contributions)}"

end

end

# (see JavaBuildpack::Component::BaseComponent#release)

def release

dep_directories.each do |dep_directory|

config = config(config_file(dep_directory))

add_bin(dep_directory)

add_lib(dep_directory)

add_additional_libraries(config)

add_environment_variables(config)

add_extension_directories(config)

add_java_opts(config)

add_security_providers(config)

end

end

private

def add_additional_libraries(config)

additional_libraries = config['config']['additional_libraries']

return unless additional_libraries

additional_libraries.each do |additional_library|

@droplet.additional_libraries << Pathname.new(additional_library)

end

'Additional Libraries'

end

def add_agentpaths(java_opts)

agentpaths = java_opts['agentpaths']

return unless agentpaths

agentpaths.each do |agentpath|

@droplet.java_opts.add_agentpath Pathname.new(agentpath)

end

'Agents'

end

def add_agentpaths_with_props(java_opts)

agentpaths = java_opts['agentpaths_with_props']

return unless agentpaths

agentpaths.each do |agentpath, props|

@droplet.java_opts.add_agentpath_with_props Pathname.new(agentpath), props

end

'Agent with Properties'

end

def add_bin(dep_directory)

bin_directory = dep_directory + 'bin'

return unless bin_directory.exist?

@droplet.environment_variables

.add_environment_variable('PATH', "$PATH:#{qualify_path(bin_directory, @droplet.root)}")

'$PATH'

end

def add_bootclasspath_ps(java_opts)

bootclasspath_ps = java_opts['bootclasspath_ps']

return unless bootclasspath_ps

bootclasspath_ps.each do |bootclasspath_p|

@droplet.java_opts.add_bootclasspath_p Pathname.new(bootclasspath_p)

end

'Boot Classpaths'

end

def add_environment_variables(config)

environment_variables = config['config']['environment_variables']

return unless environment_variables

environment_variables.each do |key, value|

path = Pathname.new(value)

if path.exist?

@droplet.environment_variables.add_environment_variable key, path

else

@droplet.environment_variables.add_environment_variable key, value

end

end

'Environment Variables'

end

def add_extension_directories(config)

extension_directories = config['config']['extension_directories']

return unless extension_directories

extension_directories.each do |extension_directory|

@droplet.extension_directories << Pathname.new(extension_directory)

end

'Extension Directories'

end

def add_javaagent(java_opts)

javaagents = java_opts['javaagents']

return unless javaagents

javaagents.each do |javaagent|

@droplet.java_opts.add_javaagent Pathname.new(javaagent)

end

'Java Agents'

end

def add_java_opts(config)

java_opts = config['config']['java_opts']

return unless java_opts

[

add_agentpaths(java_opts),

add_agentpaths_with_props(java_opts),

add_bootclasspath_ps(java_opts),

add_javaagent(java_opts),

add_options(java_opts),

add_preformatted_options(java_opts),

add_system_properties(java_opts)

]

end

def add_lib(dep_directory)

lib_directory = dep_directory + 'lib'

return unless lib_directory.exist?

@droplet.environment_variables

.add_environment_variable('LD_LIBRARY_PATH',

"$LD_LIBRARY_PATH:#{qualify_path(lib_directory, @droplet.root)}")

'$LD_LIBRARY_PATH'

end

def add_options(java_opts)

options = java_opts['options']

return unless options

options.each do |key, value|

path = Pathname.new(value)

if path.exist?

@droplet.java_opts.add_option key, path

else

@droplet.java_opts.add_option key, value

end

end

'Options'

end

def add_preformatted_options(java_opts)

preformatted_options = java_opts['preformatted_options']

return unless preformatted_options

preformatted_options.each do |preformatted_option|

@droplet.java_opts.add_preformatted_options preformatted_option

end

'Preformatted Options'

end

def add_security_providers(config)

security_providers = config['config']['security_providers']

return unless security_providers

security_providers.each do |security_provider|

@droplet.security_providers << security_provider

end

'Security Providers'

end

def add_system_properties(java_opts)

system_properties = java_opts['system_properties']

return unless system_properties

system_properties.each do |key, value|

path = Pathname.new(value)

if path.exist?

@droplet.java_opts.add_system_property key, path

else

@droplet.java_opts.add_system_property key, value

end

end

'System Properties'

end

def config(config_file)

YAML.load_file(config_file)

end

def config_file(dep_directory)

dep_directory + 'config.yml'

end

def contributions_message(contributions)

return if contributions.compact.empty?

" contributed to: #{contributions.flatten.compact.sort.join(', ')}"

end

def dep_directories

deps = Pathname.glob('/tmp/*/deps').first

return [] unless deps

deps

.children

.select { |dep_directory| config_file(dep_directory).exist? }

.sort_by(&:basename)

end

def log_configuration(config)

@logger.debug { "Configuration: #{config}" }

end

def log_dep_contents(dep_directory)

@logger.debug do

paths = []

dep_directory.find { |f| paths << f.relative_path_from(dep_directory).to_s }

"Application Contents (#{dep_directory}): #{paths}"

end

end

def name(config)

config['name']

end

def names(dep_directories)

dep_directories.map { |dep_directory| name(config(config_file(dep_directory))) }

end

end

end