Class: GDK::Dependencies::Checker

Inherits:
Object
  • Object
show all
Defined in:
lib/gdk/dependencies/checker.rb

Constant Summary collapse

EXPECTED_GO_VERSION = 
'1.20'
EXPECTED_YARN_VERSION = 
'1.22.5'
EXPECTED_NODEJS_VERSION = 
'20.12.2'
EXPECTED_POSTGRESQL_VERSION = 
GDK::Postgresql.target_version.to_s
EXPECTED_REDIS_VERSION = 
GDK::Redis.target_version.to_s

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Checker

Returns a new instance of Checker.



18
19
20
 
# File 'lib/gdk/dependencies/checker.rb', line 18

def initialize
  @error_messages = []
end

Instance Attribute Details

#error_messages ⇒ Object (readonly)

Returns the value of attribute error_messages.



12
13
14
 
# File 'lib/gdk/dependencies/checker.rb', line 12

def error_messages
  @error_messages
end

Class Method Details

.parse_version(string, prefix: '') ⇒ Object 



14
15
16
 
# File 'lib/gdk/dependencies/checker.rb', line 14

def self.parse_version(string, prefix: '')
  string[/#{prefix}((\d+\.\d+)(\.\d+)*)/, 1]
end

Instance Method Details

#check_all ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/gdk/dependencies/checker.rb', line 22

def check_all
  check_ruby_version
  check_go_version
  check_nodejs_version
  check_yarn_version
  check_postgresql_version
  check_redis_version

  check_brew_dependencies_installed
  check_exiftool_installed
  check_git_installed
  check_graphicsmagick_installed
  check_minio_installed
  check_runit_installed
  check_nginx_installed

  check_ruby_gems_ok
end

#check_binary(binary, name: binary) ⇒ Object 



41
42
43
44
45
 
# File 'lib/gdk/dependencies/checker.rb', line 41

def check_binary(binary, name: binary)
  Utils.find_executable(binary).tap do |result|
    @error_messages << missing_dependency(name) unless result
  end
end

#check_brew_dependencies_installed ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/gdk/dependencies/checker.rb', line 137

def check_brew_dependencies_installed
  cmd = 'brew bundle check -v --no-upgrade'
  result = Shellout.new(cmd).try_run

  missing_dependencies = result.scan(/(Cask|Formula) (.*?) needs to be installed./).map(&:last) unless result.include?("The Brewfile's dependencies are satisfied.")

  return if missing_dependencies.nil? || missing_dependencies.empty? || ENV['OSTYPE'] != 'darwin'

  msg = <<~MESSAGE
  The following Brewfile's dependencies are missing or outdated:

  - #{missing_dependencies.join("\n- ")}

  To install these dependencies, run the following command:

    (cd #{config.gdk_root} && brew bundle)
  MESSAGE
  @error_messages << msg
end

#check_exiftool_installed ⇒ Object 



157
158
159
160
161
162
 
# File 'lib/gdk/dependencies/checker.rb', line 157

def check_exiftool_installed
  return if system("exiftool -ver >/dev/null 2>&1")

  msg = "You may need to run 'brew reinstall exiftool'." if GDK::Machine.macos?
  @error_messages << missing_dependency('Exiftool', more_detail: msg)
end

#check_git_installed ⇒ Object 



164
165
166
 
# File 'lib/gdk/dependencies/checker.rb', line 164

def check_git_installed
  check_binary('git')
end

#check_go_version ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/gdk/dependencies/checker.rb', line 64

def check_go_version
  return unless check_binary('go')

  current_version = Checker.parse_version(`go version`, prefix: 'go')
  expected = Gem::Version.new(EXPECTED_GO_VERSION)

  raise MissingDependency unless current_version

  actual = Gem::Version.new(current_version)
  @error_messages << require_minimum_version('Go', actual, expected) if actual < expected
rescue Errno::ENOENT, MissingDependency
  @error_messages << missing_dependency('Go', minimum_version: EXPECTED_GO_VERSION)
end

#check_graphicsmagick_installed ⇒ Object 



168
169
170
 
# File 'lib/gdk/dependencies/checker.rb', line 168

def check_graphicsmagick_installed
  @error_messages << missing_dependency('GraphicsMagick') unless system("gm version >/dev/null 2>&1")
end

#check_minio_installed ⇒ Object 



172
173
174
175
176
 
# File 'lib/gdk/dependencies/checker.rb', line 172

def check_minio_installed
  return unless config.object_store.enabled?

  @error_messages << missing_dependency('MinIO') unless system('minio --help >/dev/null 2>&1')
end

#check_nginx_installed ⇒ Object 



182
183
184
185
186
 
# File 'lib/gdk/dependencies/checker.rb', line 182

def check_nginx_installed
  return unless config.nginx?

  check_binary(config.nginx.bin, name: 'nginx')
end

#check_nodejs_version ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/gdk/dependencies/checker.rb', line 78

def check_nodejs_version
  return unless check_binary('node')

  current_version = Checker.parse_version(`node --version`, prefix: 'v')

  raise MissingDependency unless current_version

  actual = Gem::Version.new(current_version)
  expected = Gem::Version.new(EXPECTED_NODEJS_VERSION)

  @error_messages << require_minimum_version('Node.js', actual, expected) if actual < expected
rescue Errno::ENOENT, MissingDependency
  @error_messages << missing_dependency('Node.js', minimum_version: EXPECTED_NODEJS_VERSION)
end

#check_postgresql_version ⇒ Object 



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/gdk/dependencies/checker.rb', line 107

def check_postgresql_version
  psql = config.postgresql.bin_dir.join('psql')

  return unless check_binary(psql)

  current_version = Checker.parse_version(`#{psql} --version`, prefix: 'psql \(PostgreSQL\) ')
  expected = Gem::Version.new(EXPECTED_POSTGRESQL_VERSION)

  raise MissingDependency unless current_version

  actual = Gem::Version.new(current_version)
  @error_messages << require_minimum_version('PostgreSQL', actual, expected) if actual < expected
rescue Errno::ENOENT, MissingDependency
  @error_messages << missing_dependency('PostgreSQL', minimum_version: expected)
end

#check_redis_version ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/gdk/dependencies/checker.rb', line 123

def check_redis_version
  return unless check_binary('redis-server')

  current_version = Checker.parse_version(`redis-server --version`, prefix: 'Redis server v=')
  expected = Gem::Version.new(EXPECTED_REDIS_VERSION)

  raise MissingDependency unless current_version

  actual = Gem::Version.new(current_version)
  @error_messages << require_minimum_version('redis', actual, expected) if actual < expected
rescue Errno::ENOENT, MissingDependency
  @error_messages << missing_dependency('redis', minimum_version: expected)
end

#check_ruby_gems_ok ⇒ Object 



200
201
202
203
204
205
206
 
# File 'lib/gdk/dependencies/checker.rb', line 200

def check_ruby_gems_ok
  checker = GDK::Diagnostic::RubyGems.new(allow_gem_not_installed: true)
  return if checker.success?

  @error_messages << "ERROR: #{checker.detail}"
  @error_messages << nil
end

#check_ruby_version ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/gdk/dependencies/checker.rb', line 47

def check_ruby_version
  return unless check_binary('ruby')

  cmd = 'ruby --version'
  # .tool-versions may have changed during a `gdk update`, so we
  # should execute ruby using asdf to avoid a stale PATH.
  cmd = "asdf exec #{cmd}" if GDK::Dependencies.asdf_available?

  raw_version_match = Shellout.new(cmd).try_run.match(/\Aruby (.+)p\d+ \(.+\z/)
  return unless raw_version_match

  actual = Gem::Version.new(raw_version_match[1])
  expected = Gem::Version.new(GitlabVersions.new.ruby_version)

  @error_messages << require_minimum_version('Ruby', actual, expected) if actual < expected
end

#check_runit_installed ⇒ Object 



178
179
180
 
# File 'lib/gdk/dependencies/checker.rb', line 178

def check_runit_installed
  check_binary('runsvdir', name: 'Runit')
end

#check_yarn_version ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/gdk/dependencies/checker.rb', line 93

def check_yarn_version
  return unless check_binary('yarn')

  current_version = Checker.parse_version(`yarn --version`)
  expected = Gem::Version.new(EXPECTED_YARN_VERSION)

  raise MissingDependency unless current_version

  actual = Gem::Version.new(current_version)
  @error_messages << require_minimum_version('Yarn', actual, expected) if actual < expected
rescue Errno::ENOENT, MissingDependency
  @error_messages << missing_dependency('Yarn', minimum_version: expected)
end

#missing_dependency(dependency, minimum_version: nil, more_detail: nil) ⇒ Object 



192
193
194
195
196
197
198
 
# File 'lib/gdk/dependencies/checker.rb', line 192

def missing_dependency(dependency, minimum_version: nil, more_detail: nil)
  message = "ERROR: #{dependency} is not installed or not available in your PATH."
  message += " #{minimum_version} or higher is required." unless minimum_version.nil?
  message += " #{more_detail}" unless more_detail.nil?

  message
end

#require_minimum_version(dependency, actual, expected) ⇒ Object 



188
189
190
 
# File 'lib/gdk/dependencies/checker.rb', line 188

def require_minimum_version(dependency, actual, expected)
  "ERROR: #{dependency} version #{actual} detected, please install #{dependency} version #{expected} or higher."
end