Top Level Namespace

Defined Under Namespace

Modules: Aws

Constant Summary collapse

OS_BINARIES =

Maps OS name to crt binary name.

{
  'darwin' => 'libaws-crt-ffi.dylib',
  'linux' => 'libaws-crt-ffi.so',
  'mingw32' => 'aws-crt-ffi.dll'
}.freeze
DEFAULT_BINARY = 
'libaws-crt-ffi.so'
CMAKE_PATH = 
find_executable('cmake3') || find_executable('cmake')
CMAKE = 
File.basename(CMAKE_PATH)
CMAKE_VERSION = 
cmake_version

Instance Method Summary collapse

Instance Method Details

#cmake_has_parallel_flag? ⇒ Boolean

whether installed cmake supports –parallel build flag

Returns:

  • (Boolean) 


22
23
24
 
# File 'ext/compile.rb', line 22

def cmake_has_parallel_flag?
  (CMAKE_VERSION <=> [3, 12]) >= 0
end

#cmake_version ⇒ Object 



13
14
15
16
17
 
# File 'ext/compile.rb', line 13

def cmake_version
  version_str = `#{CMAKE} --version`
  match = /(\d+)\.(\d+)\.(\d+)/.match(version_str)
  [match[1].to_i, match[2].to_i, match[3].to_i]
end

#compile_bin(cpu = host_cpu) ⇒ Object

Compile bin to expected location



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'ext/compile.rb', line 44

def compile_bin(cpu = host_cpu)
  platform = target_platform(cpu)
  native_dir = File.expand_path('../aws-crt-ffi', File.dirname(__FILE__))
  tmp_dir = File.expand_path("../tmp/#{platform.cpu}", File.dirname(__FILE__))
  tmp_build_dir = File.expand_path('build', tmp_dir)

  # We need cmake to "install" aws-crt-ffi so that the binaries end up in a
  # predictable location. But cmake still adds subdirectories we don't want,
  # so we'll "install" under tmp, and manually copy to bin/ after that.
  tmp_install_dir = File.expand_path('install', tmp_dir)

  build_type = 'RelWithDebInfo'

  config_cmd = [
    CMAKE,
    "-H#{native_dir}",
    "-B#{tmp_build_dir}",
    "-DCMAKE_INSTALL_PREFIX=#{tmp_install_dir}",
    "-DCMAKE_BUILD_TYPE=#{build_type}",
    '-DBUILD_TESTING=OFF',
  ]

  # macOS can cross-compile for arm64 or x86_64.
  # This lets us prepare both types of gems from either type of machine.
  if platform.os == 'darwin'
    config_cmd.append("-DCMAKE_OSX_ARCHITECTURES=#{platform.cpu}")
  end

  build_cmd = [
    CMAKE,
    '--build', tmp_build_dir,
    '--target', 'install',
    '--config', build_type,
  ]

  # Build using all processors
  if cmake_has_parallel_flag?
    build_cmd.append('--parallel')
    build_cmd.append(Etc.nprocessors.to_s)
  end

  run_cmd(config_cmd)
  run_cmd(build_cmd)

  # Move file to bin/, instead of where cmake installed it under tmp/
  bin_dir = crt_bin_dir(platform)
  FileUtils.mkdir_p(bin_dir)
  bin_name = crt_bin_name(platform)
  search_dirs = [
    'bin', # windows
    'lib64', # some 64bit unix variants
    'lib', # some unix variants
  ]
  tmp_path = find_file(bin_name, search_dirs, tmp_install_dir)
  FileUtils.cp(tmp_path, bin_dir, verbose: true)
end

#crt_bin_dir(platform) ⇒ String

Return the directory of the CRT library for the platform

Returns:

  • (String) —

    return the directory of the CRT library for the platform



29
30
31
32
33
 
# File 'lib/aws-crt/platforms.rb', line 29

def crt_bin_dir(platform)
  ENV['AWS_CRT_RUBY_BIN_DIR'] ||
    File.expand_path("../../bin/#{platform.cpu}",
                     File.dirname(__FILE__))
end

#crt_bin_name(platform) ⇒ String

Return the file name for the CRT library for the platform

Returns:

  • (String) —

    return the file name for the CRT library for the platform



24
25
26
 
# File 'lib/aws-crt/platforms.rb', line 24

def crt_bin_name(platform)
  OS_BINARIES[platform.os] || DEFAULT_BINARY
end

#crt_bin_path(platform) ⇒ String

Return the path to the CRT library for the platform

Returns:

  • (String) —

    return the path to the CRT library for the platform



36
37
38
 
# File 'lib/aws-crt/platforms.rb', line 36

def crt_bin_path(platform)
  File.expand_path(crt_bin_name(platform), crt_bin_dir(platform))
end

#find_file(name, search_dirs, base_dir) ⇒ Object 



34
35
36
37
38
39
40
41
 
# File 'ext/compile.rb', line 34

def find_file(name, search_dirs, base_dir)
  search_dirs.each do |search_dir|
    dir = File.expand_path(search_dir, base_dir)
    file_path = File.expand_path(name, dir)
    return file_path if File.exist?(file_path)
  end
  raise "Cannot find #{name}"
end

#host_cpu ⇒ String

Returns host cpu, even on jruby.

Returns:

  • (String) —

    host cpu, even on jruby



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/aws-crt/platforms.rb', line 51

def host_cpu
  case RbConfig::CONFIG['host_cpu']
  when /86_64/
    'x86_64'
  when /86/
    'x86'
  else
    RbConfig::CONFIG['host_cpu']
  end
end

#host_os ⇒ String

Returns host os, even on jruby.

Returns:

  • (String) —

    host os, even on jruby



63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/aws-crt/platforms.rb', line 63

def host_os
  case RbConfig::CONFIG['host_os']
  when /darwin/
    'darwin'
  when /linux/
    'linux'
  when /mingw|mswin/
    'mingw32'
  else
    RbConfig::CONFIG['host_os']
  end
end

#host_string ⇒ String

Returns generate a string that can be used with Gem::Platform.

Returns:

  • (String) —

    generate a string that can be used with Gem::Platform



41
42
43
 
# File 'lib/aws-crt/platforms.rb', line 41

def host_string
  target_string(host_cpu)
end

#local_platform ⇒ Gem::Platform

host os/cpu for Jruby

Returns:

  • (Gem::Platform) —

    similar to Gem::Platform.local but will return



14
15
16
 
# File 'lib/aws-crt/platforms.rb', line 14

def local_platform
  Gem::Platform.new(host_string)
end

#run_cmd(args) ⇒ Object 



26
27
28
29
30
31
32
 
# File 'ext/compile.rb', line 26

def run_cmd(args)
  # use shellwords.join() for printing, don't pass that string to system().
  # system() does better cross-platform when the args array is passed in.
  cmd_str = Shellwords.join(args)
  puts cmd_str
  system(*args) || raise("Error running: #{cmd_str}")
end

#target_platform(cpu) ⇒ Gem::Platform

Return Gem::Platform for host os with target cpu

Returns:

  • (Gem::Platform) —

    return Gem::Platform for host os with target cpu



19
20
21
 
# File 'lib/aws-crt/platforms.rb', line 19

def target_platform(cpu)
  Gem::Platform.new(target_string(cpu))
end

#target_string(cpu) ⇒ String

Returns generate a string that can be used with Gem::Platform.

Returns:

  • (String) —

    generate a string that can be used with Gem::Platform



46
47
48
 
# File 'lib/aws-crt/platforms.rb', line 46

def target_string(cpu)
  "#{cpu}-#{host_os}"
end