Module: ModuleSync

Includes:
Constants
Defined in:
lib/modulesync.rb,
lib/modulesync/cli.rb,
lib/modulesync/git.rb,
lib/modulesync/hook.rb,
lib/modulesync/util.rb,
lib/modulesync/renderer.rb,
lib/modulesync/settings.rb,
lib/modulesync/constants.rb

Defined Under Namespace

Modules: Constants, Git, Renderer, Util Classes: CLI, Hook, Settings

Constant Summary

Constants included from Constants

Constants::CONF_FILE, Constants::GLOBAL_DEFAULTS_KEY, Constants::HOOK_FILE, Constants::MODULESYNC_CONF_FILE, Constants::MODULE_CONF_FILE, Constants::MODULE_FILES_DIR

Class Method Summary collapse

Class Method Details

.config_defaults ⇒ Object 



15
16
17
18
19
20
21
22
 
# File 'lib/modulesync.rb', line 15

def self.config_defaults
  {
    :project_root         => 'modules/',
    :managed_modules_conf => 'managed_modules.yml',
    :configs              => '.',
    :tag_pattern          => '%s'
  }
end

.hook(options) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
 
# File 'lib/modulesync.rb', line 62

def self.hook(options)
  hook = Hook.new(HOOK_FILE, options)

  case options[:hook]
  when 'activate'
    hook.activate
  when 'deactivate'
    hook.deactivate
  end
end

.local_file(config_path, file) ⇒ Object 



24
25
26
 
# File 'lib/modulesync.rb', line 24

def self.local_file(config_path, file)
  "#{config_path}/#{MODULE_FILES_DIR}/#{file}"
end

.local_files(path) ⇒ Object 



32
33
34
35
36
37
38
39
40
 
# File 'lib/modulesync.rb', line 32

def self.local_files(path)
  if File.exist?(path)
    # only select *.erb files, and strip the extension. This way all the code will only have to handle bare paths, except when reading the actual ERB text
    local_files = Find.find(path).find_all { |p| p =~ /.erb$/ && !File.directory?(p) }.collect { |p| p.chomp('.erb') }.to_a
  else
    puts "#{path} does not exist. Check that you are working in your module configs directory or that you have passed in the correct directory with -c."
    exit
  end
end

.manage_file(filename, settings, options) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/modulesync.rb', line 73

def self.manage_file(filename, settings, options)
  module_name = settings.additional_settings[:puppet_module]
  configs = settings.build_file_configs(filename)
  if configs['delete']
    Renderer.remove(module_file(options[:project_root], module_name, filename))
  else
    templatename = local_file(options[:configs], filename)
    begin
      erb = Renderer.build(templatename)
      template = Renderer.render(erb, configs)
      Renderer.sync(template, module_file(options[:project_root], module_name, filename))
    rescue # rubocop:disable Lint/RescueWithoutErrorClass
      STDERR.puts "Error while rendering #{filename}"
      raise
    end
  end
end

.manage_module(puppet_module, module_files, module_options, defaults, options) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/modulesync.rb', line 91

def self.manage_module(puppet_module, module_files, module_options, defaults, options)
  puts "Syncing #{puppet_module}"
  namespace, module_name = module_name(puppet_module, options[:namespace])
  unless options[:offline]
    git_base = options[:git_base]
    git_uri = "#{git_base}#{namespace}"
    Git.pull(git_uri, module_name, options[:branch], options[:project_root], module_options || {})
  end
  module_configs = Util.parse_config("#{options[:project_root]}/#{module_name}/#{MODULE_CONF_FILE}")
  settings = Settings.new(defaults[GLOBAL_DEFAULTS_KEY] || {},
                          defaults,
                          module_configs[GLOBAL_DEFAULTS_KEY] || {},
                          module_configs,
                          :puppet_module => module_name,
                          :git_base => git_base,
                          :namespace => namespace)
  settings.unmanaged_files(module_files).each do |filename|
    puts "Not managing #{filename} in #{module_name}"
  end

  files_to_manage = settings.managed_files(module_files)
  files_to_manage.each { |filename| manage_file(filename, settings, options) }

  if options[:noop]
    Git.update_noop(module_name, options)
  elsif !options[:offline]
    Git.update(module_name, files_to_manage, options)
  end
end

.managed_modules(config_file, filter, negative_filter) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
 
# File 'lib/modulesync.rb', line 46

def self.managed_modules(config_file, filter, negative_filter)
  managed_modules = Util.parse_config(config_file)
  if managed_modules.empty?
    puts "No modules found in #{config_file}. Check that you specified the right :configs directory and :managed_modules_conf file."
    exit
  end
  managed_modules.select! { |m| m =~ Regexp.new(filter) } unless filter.nil?
  managed_modules.reject! { |m| m =~ Regexp.new(negative_filter) } unless negative_filter.nil?
  managed_modules
end

.module_file(project_root, puppet_module, file) ⇒ Object 



28
29
30
 
# File 'lib/modulesync.rb', line 28

def self.module_file(project_root, puppet_module, file)
  "#{project_root}/#{puppet_module}/#{file}"
end

.module_files(local_files, path) ⇒ Object 



42
43
44
 
# File 'lib/modulesync.rb', line 42

def self.module_files(local_files, path)
  local_files.map { |file| file.sub(/#{path}/, '') }
end

.module_name(module_name, default_namespace) ⇒ Object 



57
58
59
60
 
# File 'lib/modulesync.rb', line 57

def self.module_name(module_name, default_namespace)
  return [default_namespace, module_name] unless module_name.include?('/')
  ns, mod = module_name.split('/')
end

.update(options) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/modulesync.rb', line 121

def self.update(options)
  options = config_defaults.merge(options)
  defaults = Util.parse_config("#{options[:configs]}/#{CONF_FILE}")

  path = "#{options[:configs]}/#{MODULE_FILES_DIR}"
  local_files = self.local_files(path)
  module_files = self.module_files(local_files, path)

  managed_modules = self.managed_modules("#{options[:configs]}/#{options[:managed_modules_conf]}", options[:filter], options[:negative_filter])

  errors = false
  # managed_modules is either an array or a hash
  managed_modules.each do |puppet_module, module_options|
    begin
      manage_module(puppet_module, module_files, module_options, defaults, options)
    rescue # rubocop:disable Lint/RescueWithoutErrorClass
      STDERR.puts "Error while updating #{puppet_module}"
      raise unless options[:skip_broken]
      errors = true
      puts "Skipping #{puppet_module} as update process failed"
    end
  end
  exit 1 if errors && options[:fail_on_warnings]
end