Class: Kafo::KafoConfigure

Inherits:
Clamp::Command
  • Object
show all
Includes:
StringHelper
Defined in:
lib/kafo/kafo_configure.rb

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from StringHelper

#dashize, #parametrize, #underscore, #with_prefix

Constructor Details

#initialize(*args) ⇒ KafoConfigure

Returns a new instance of KafoConfigure.



42
43
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
 
# File 'lib/kafo/kafo_configure.rb', line 42

def initialize(*args)
  self.class.logger           = Logger.new
  self.class.config_file      = config_file
  self.class.config           = Configuration.new(self.class.config_file)
  self.class.root_dir         = File.expand_path(self.class.config.app[:installer_dir])
  modules_dir                 = self.class.config.app[:modules_dir] || (self.class.config.app[:installer_dir] + '/modules')
  self.class.modules_dir      = File.expand_path(modules_dir)
  self.class.gem_root         = File.join(File.dirname(__FILE__), '../../')
  self.class.kafo_modules_dir = self.class.config.app[:kafo_modules_dir] || (self.class.gem_root + '/modules')
  @progress_bar               = nil
  self.class.hooking.load
  self.class.hooking.kafo     = self

  super

  self.class.hooking.execute(:boot)
  set_app_options
  # we need to parse app config params using clamp even before run method does it
  # so we limit parsing only to app config options (because of --help and later defined params)
  parse clamp_app_arguments
  parse_app_arguments
  Logger.setup
  ColorScheme.new(config).setup

  self.class.hooking.execute(:init)
  set_parameters # here the params gets parsed and we need app config populated
  set_options
end

Class Attribute Details

.app_options ⇒ Object

Returns the value of attribute app_options.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def app_options
  @app_options
end

.config ⇒ Object

Returns the value of attribute config.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def config
  @config
end

.config_file ⇒ Object

Returns the value of attribute config_file.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def config_file
  @config_file
end

.gem_root ⇒ Object

Returns the value of attribute gem_root.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def gem_root
  @gem_root
end

.hooking ⇒ Object 



37
38
39
 
# File 'lib/kafo/kafo_configure.rb', line 37

def hooking
  @hooking ||= Hooking.new
end

.kafo_modules_dir ⇒ Object

Returns the value of attribute kafo_modules_dir.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def kafo_modules_dir
  @kafo_modules_dir
end

.logger ⇒ Object

Returns the value of attribute logger.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def logger
  @logger
end

.modules_dir ⇒ Object

Returns the value of attribute modules_dir.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def modules_dir
  @modules_dir
end

.root_dir ⇒ Object

Returns the value of attribute root_dir.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def root_dir
  @root_dir
end

.temp_config_file ⇒ Object

Returns the value of attribute temp_config_file.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def temp_config_file
  @temp_config_file
end

.verbose ⇒ Object

Returns the value of attribute verbose.



29
30
31
 
# File 'lib/kafo/kafo_configure.rb', line 29

def verbose
  @verbose
end

Class Method Details

.app_option(*args, &block) ⇒ Object 



183
184
185
186
187
 
# File 'lib/kafo/kafo_configure.rb', line 183

def self.app_option(*args, &block)
  self.app_options ||= []
  self.app_options.push self.option(*args, &block)
  self.app_options.last
end

.cleanup ⇒ Object 



152
153
154
155
156
157
158
 
# File 'lib/kafo/kafo_configure.rb', line 152

def self.cleanup
  # make sure default values are removed from /tmp
  (self.cleanup_paths + ['/tmp/default_values.yaml']).each do |file|
    logger.debug "Cleaning #{file}"
    FileUtils.rm_rf(file)
  end
end

.cleanup_paths ⇒ Object 



33
34
35
 
# File 'lib/kafo/kafo_configure.rb', line 33

def cleanup_paths
  @cleanup_paths ||= []
end

.exit(code, &block) ⇒ Object 



126
127
128
129
130
131
 
# File 'lib/kafo/kafo_configure.rb', line 126

def self.exit(code, &block)
  @exit_code = translate_exit_code(code)
  block.call if block
  cleanup
  throw :exit
end

.exit_code ⇒ Object 



133
134
135
 
# File 'lib/kafo/kafo_configure.rb', line 133

def self.exit_code
  @exit_code ||= 0
end

.help(*args) ⇒ Object 



176
177
178
179
180
181
 
# File 'lib/kafo/kafo_configure.rb', line 176

def self.help(*args)
  kafo          = args.pop
  builder_class = kafo.full_help? ? HelpBuilders::Advanced : HelpBuilders::Basic
  args.push builder_class.new(kafo.params)
  super(*args)
end

.register_cleanup_path(path) ⇒ Object 



160
161
162
 
# File 'lib/kafo/kafo_configure.rb', line 160

def self.register_cleanup_path(path)
  self.cleanup_paths<< path
end

.run ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/kafo/kafo_configure.rb', line 115

def self.run
  catch :exit do
    return super
  end
  Kernel.exit(self.exit_code) # fail in initialize
end

.translate_exit_code(code) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/kafo/kafo_configure.rb', line 137

def self.translate_exit_code(code)
  return code if code.is_a? Fixnum
  error_codes = { :invalid_system => 20,
                  :invalid_values => 21,
                  :manifest_error => 22,
                  :no_answer_file => 23,
                  :unknown_module => 24,
                  :defaults_error => 25 }
  if error_codes.has_key? code
    return error_codes[code]
  else
    raise "Unknown code #{code}"
  end
end

Instance Method Details

#add_module(name) ⇒ Object 



201
202
203
204
205
 
# File 'lib/kafo/kafo_configure.rb', line 201

def add_module(name)
  config.add_module(name)
  reset_params_cache
  self.module(name)
end

#cleanup_paths ⇒ Object 



168
169
170
 
# File 'lib/kafo/kafo_configure.rb', line 168

def cleanup_paths
  self.class.cleanup_paths
end

#config ⇒ Object 



71
72
73
 
# File 'lib/kafo/kafo_configure.rb', line 71

def config
  self.class.config
end

#execute ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/kafo/kafo_configure.rb', line 79

def execute
  catch :exit do
    parse_cli_arguments

    if (self.class.verbose = verbose?)
      Logger.setup_verbose
    else
      @progress_bar = self.class.config.app[:colors] ? ProgressBars::Colored.new : ProgressBars::BlackWhite.new
    end

    unless SystemChecker.check
      puts "Your system does not meet configuration criteria"
      exit(:invalid_system)
    end

    if interactive?
      wizard = Wizard.new(self)
      wizard.run
    else
      unless validate_all
        puts "Error during configuration, exiting"
        exit(:invalid_values)
      end
    end

    if dont_save_answers?
      self.class.temp_config_file = temp_config_file
      store_params(temp_config_file)
    else
      store_params
    end
    run_installation
  end
  return self
end

#exit_code ⇒ Object 



122
123
124
 
# File 'lib/kafo/kafo_configure.rb', line 122

def exit_code
  self.class.exit_code
end

#help ⇒ Object 



172
173
174
 
# File 'lib/kafo/kafo_configure.rb', line 172

def help
  self.class.help(invocation_path, self)
end

#logger ⇒ Object 



75
76
77
 
# File 'lib/kafo/kafo_configure.rb', line 75

def logger
  self.class.logger
end

#module(name) ⇒ Object 



211
212
213
 
# File 'lib/kafo/kafo_configure.rb', line 211

def module(name)
  modules.detect { |m| m.name == name }
end

#modules ⇒ Object 



207
208
209
 
# File 'lib/kafo/kafo_configure.rb', line 207

def modules
  config.modules.sort
end

#param(mod, name) ⇒ Object 



215
216
217
 
# File 'lib/kafo/kafo_configure.rb', line 215

def param(mod, name)
  params.detect { |p| p.name == name && p.module.name == mod }
end

#params ⇒ Object 



189
190
191
192
193
194
 
# File 'lib/kafo/kafo_configure.rb', line 189

def params
  @params ||= modules.map(&:params).flatten
rescue KafoParsers::ModuleName => e
  puts e
  exit(:unknown_module)
end

#register_cleanup_path(path) ⇒ Object 



164
165
166
 
# File 'lib/kafo/kafo_configure.rb', line 164

def register_cleanup_path(path)
  self.class.register_cleanup_path(path)
end

#reset_params_cache ⇒ Object 



196
197
198
199
 
# File 'lib/kafo/kafo_configure.rb', line 196

def reset_params_cache
  @params = nil
  params
end