Class: Jets::Booter

Inherits:
Object
  • Object
show all
Defined in:
lib/jets/booter.rb

Class Method Summary collapse

Class Method Details

.app_initializers ⇒ Object

All Turbines



101
102
103
104
105
 
# File 'lib/jets/booter.rb', line 101

def app_initializers
  Dir.glob("#{Jets.root}/config/initializers/**/*").each do |path|
    load path
  end
end

.boot! ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/jets/booter.rb', line 6

def boot!
  return if @booted

  confirm_jets_project!
  Jets::Bundle.require

  Jets.application.setup!

  # Turbines are loaded after setup_autoload_paths in Jets.application.setup!  Some Turbine options are defined
  # in the project so setup must happen before internal Turbines are loaded.
  load_internal_turbines

  run_turbines(:initializers)
  # Load configs after Turbine initializers so Turbines can defined some config options and they are available in
  # user's project environment configs.
  Jets.application.configs!
  app_initializers
  run_turbines(:after_initializers)
  Jets.application.finish!

  setup_db # establish db connections in Lambda Execution Context.
  # The eager load calls connects_to in models and establish those connections in Lambda Execution Context also.
  eager_load

  # TODO: Figure out how to build middleware during Jets.boot without breaking jets new and webpacker:install
  # build_middleware_stack

  @booted = true
end

.build_middleware_stack ⇒ Object

Builds and memoize stack so it only gets built on bootup



119
120
121
 
# File 'lib/jets/booter.rb', line 119

def build_middleware_stack
  Jets.application.build_stack
end

.check_config_ru! ⇒ Object 



135
136
137
138
139
140
141
142
143
144
 
# File 'lib/jets/booter.rb', line 135

def check_config_ru!
  config_ru = File.read("#{Jets.root}/config.ru")
  unless config_ru.include?("Jets.boot")
    puts 'The config.ru file is missing Jets.boot.  Please add Jets.boot after require "jets"'.color(:red)
    puts "This was changed as made in Jets v1.1.0."
    puts "To have Jets update the config.fu file for you, you can run:\n\n"
    puts "  jets upgrade"
    exit 1
  end
end

.confirm_jets_project! ⇒ Object

Cannot call this for the jets new



124
125
126
127
128
129
 
# File 'lib/jets/booter.rb', line 124

def confirm_jets_project!
  unless File.exist?("#{Jets.root}/config/application.rb")
    puts "It does not look like you are running this command within a jets project.  Please confirm that you are in a jets project and try again.".color(:red)
    exit 1
  end
end

.connect_db ⇒ Object

Eager connect to database, so connections are established in the Lambda Execution Context and get reused. Interestingly, the connections info is stored in the shared state but the connection doesnt show up on ‘show processlist` until after a query. Have confirmed that the connection is reused and the connection count stays the same.



76
77
78
79
80
81
82
 
# File 'lib/jets/booter.rb', line 76

def connect_db
  primary_hash_config = ActiveRecord::Base.configurations.configs_for(env_name: Jets.env).find { |hash_config|
    hash_config.spec_name == "primary"
  }
  primary_config = primary_hash_config.config # config is a normal Ruby Hash
  ActiveRecord::Base.establish_connection(primary_config)
end

.eager_load ⇒ Object 



36
37
38
39
 
# File 'lib/jets/booter.rb', line 36

def eager_load
  preload_extensions
  Jets::Autoloaders.main.eager_load # Eager load project code. Rather have user find out early than later on AWS Lambda.
end

.load_internal_turbines ⇒ Object 



84
85
86
87
88
 
# File 'lib/jets/booter.rb', line 84

def load_internal_turbines
  Dir.glob("#{__dir__}/internal/turbines/**/*.rb").each do |path|
    Jets::Autoloaders.once.preload(path)
  end
end

.message ⇒ Object 



131
132
133
 
# File 'lib/jets/booter.rb', line 131

def message
  "Jets booting up in #{Jets.env.color(:green)} mode!"
end

.preload_extensions ⇒ Object 



41
42
43
44
45
46
47
48
49
50
 
# File 'lib/jets/booter.rb', line 41

def preload_extensions
  base_path = "#{Jets.root}/app/extensions"
  Dir.glob("#{base_path}/**/*.rb").each do |path|
    next unless File.file?(path)

    class_name = path.sub("#{base_path}/", '').sub(/\.rb/,'').camelize
    klass = class_name.constantize # autoload
    Jets::Lambda::Functions.extend(klass)
  end
end

.run_turbines(name) ⇒ Object

run_turbines(:initializers) run_turbines(:after_initializers)



109
110
111
112
113
114
115
116
 
# File 'lib/jets/booter.rb', line 109

def run_turbines(name)
  Jets::Turbine.subclasses.each do |subclass|
    hooks = subclass.send(name) || []
    hooks.each do |label, block|
      block.call(Jets.application)
    end
  end
end

.setup_db ⇒ Object

Using ActiveRecord outside of Rails, so we need to set up the db connection ourself.

Only connects to database for ActiveRecord and when config/database.yml exists. Dynomite handles connecting to the clients lazily.



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/jets/booter.rb', line 56

def setup_db
  return unless File.exist?("#{Jets.root}/config/database.yml")

  db_configs = Jets.application.config.database
  # DatabaseTasks.database_configuration for db:create db:migrate tasks
  # Documented in DatabaseTasks that this is the right way to set it when
  # using ActiveRecord rake tasks outside of Rails.
  ActiveRecord::Tasks::DatabaseTasks.database_configuration = db_configs

  if db_configs[Jets.env].blank?
    abort("ERROR: config/database.yml exists but no environment section configured for #{Jets.env}")
  end
  ActiveRecord::Base.configurations = db_configs
  connect_db
end

.turbine_initializers ⇒ Object

All Turbines



91
92
93
94
95
96
97
98
 
# File 'lib/jets/booter.rb', line 91

def turbine_initializers
  Jets::Turbine.subclasses.each do |subclass|
    initializers = subclass.initializers || []
    initializers.each do |label, block|
      block.call(Jets.application)
    end
  end
end