Module: Fhcap::ReposHelper

Included in:
CLI::Cookbook, Tasks::TaskBase, ThorBase
Defined in:
lib/fhcap/repos_helper.rb

Instance Method Summary collapse

Instance Method Details

#find_cluster(name) ⇒ Object 



68
69
70
 
# File 'lib/fhcap/repos_helper.rb', line 68

def find_cluster(name)
  find_cluster_with_repo(name).first
end

#find_cluster_pwds(name) ⇒ Object 



76
77
78
 
# File 'lib/fhcap/repos_helper.rb', line 76

def find_cluster_pwds(name)
  find_cluster_pwds_with_repo(name).first
end

#find_cluster_pwds_with_repo(name) ⇒ Object 



80
81
82
83
 
# File 'lib/fhcap/repos_helper.rb', line 80

def find_cluster_pwds_with_repo(name)
  name = "#{name}_passwords"
  find_repo_item('clusters', ensure_json_extension(name)) || []
end

#find_cluster_with_repo(name) ⇒ Object 



72
73
74
 
# File 'lib/fhcap/repos_helper.rb', line 72

def find_cluster_with_repo(name)
  find_repo_item('clusters', ensure_json_extension(name)) || []
end

#find_data_bag(data_bag_name) ⇒ Object 



52
53
54
 
# File 'lib/fhcap/repos_helper.rb', line 52

def find_data_bag(data_bag_name)
  find_repo_item('data_bags', data_bag_name).first
end

#find_data_bag_item(data_bag_name, data_bag_item) ⇒ Object 



56
57
58
 
# File 'lib/fhcap/repos_helper.rb', line 56

def find_data_bag_item(data_bag_name, data_bag_item)
  find_repo_item('data_bags', data_bag_name, ensure_json_extension(data_bag_item)).first
end

#find_environment(environment) ⇒ Object 



60
61
62
 
# File 'lib/fhcap/repos_helper.rb', line 60

def find_environment(environment)
  find_repo_item('environments', ensure_json_extension(environment)).first
end

#find_repo_item(*args) ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/fhcap/repos_helper.rb', line 85

def find_repo_item(*args)
  repo_names.each do |repo|
    repo_args = args.dup
    repo_item_dir_method = :"repo_#{repo_args.first}_dir"
    repo_args[0] = respond_to?(repo_item_dir_method) ? send(repo_item_dir_method, repo) : repo_args.first
    item_path = File.join(repo_dir(repo), repo_args)
    if Dir.exists?(item_path) || File.exists?(item_path)
      return item_path, repo
    end
  end
  nil
end

#find_role(role) ⇒ Object 



64
65
66
 
# File 'lib/fhcap/repos_helper.rb', line 64

def find_role(role)
  find_repo_item('roles', ensure_json_extension(role)).first
end

#get_cookbook_deps(name, dependencies, options) ⇒ Object 



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/fhcap/repos_helper.rb', line 157

def get_cookbook_deps(name, dependencies, options)
  unless dependencies[name]
    require_chef_deps
    Dir.chdir(cookbook_loader.cookbooks_by_name[name].root_dir) do
      ::Chef::Knife::Deps.load_deps
      knife_deps = ::Chef::Knife::Deps.new(["."])
      knife_deps.configure_chef
      ::Chef::Config[:cookbook_path] = repo_cookbook_paths

      entries = ::Chef::ChefFS::FileSystem.list(knife_deps.local_fs, ::Chef::ChefFS::FilePattern.new("/cookbooks/#{name}/."))
      entries.each do |entry|
        get_entry_dependencies(entry, dependencies, knife_deps, options)
      end
    end
  end
  dependencies
end

#get_cookbook_meta(name, paths = repo_cookbook_paths) ⇒ Object 



153
154
155
 
# File 'lib/fhcap/repos_helper.rb', line 153

def get_cookbook_meta(name, paths=repo_cookbook_paths)
  cookbook_loader(paths).metadata[name]
end

#get_cookbook_versions(options) ⇒ Object 



115
116
117
118
119
120
121
122
123
 
# File 'lib/fhcap/repos_helper.rb', line 115

def get_cookbook_versions(options)
  cookbook_versions = {}
  get_cookbooks(options).each do |name|
    version = get_cookbook_meta(name).version
    cookbook_versions[name] = version
    yield name, version if block_given?
  end
  cookbook_versions
end

#get_cookbooks(options, default = nil, paths = repo_cookbook_paths) ⇒ Object 



125
126
127
128
129
130
131
132
133
 
# File 'lib/fhcap/repos_helper.rb', line 125

def get_cookbooks(options, default=nil, paths=repo_cookbook_paths)
  if options[:modified]
    get_modified_cookbooks(options, paths)
  elsif options[:dirty]
    get_dirty_cookbooks(options, paths)
  else
    options[:cookbooks] || (default || cookbook_loader(paths).cookbook_names)
  end
end

#get_dirty_cookbooks(options, paths = repo_cookbook_paths) ⇒ Object 



144
145
146
147
148
149
150
151
 
# File 'lib/fhcap/repos_helper.rb', line 144

def get_dirty_cookbooks(options, paths=repo_cookbook_paths)
  dirty = []
  cookbook_loader(paths).cookbook_names.each do |name|
    cookbook_dir = cookbook_loader.cookbooks_by_name[name].root_dir
    dirty << name if is_dirty?(cookbook_dir)
  end
  dirty
end

#get_entry_dependencies(entry, dependencies, knife_deps, options) ⇒ Object 



175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/fhcap/repos_helper.rb', line 175

def get_entry_dependencies(entry, dependencies, knife_deps, options)
  unless dependencies[entry.name]
    cwd = Pathname.new(options[:cwd] || Dir.pwd)
    dependencies[entry.name] = Pathname.new(entry.file_path).relative_path_from(cwd)
    child_deps = knife_deps.get_dependencies(entry)
    child_deps.each do |child|
      child_entry = ::Chef::ChefFS::FileSystem.resolve_path(knife_deps.local_fs, child)
      get_entry_dependencies(child_entry, dependencies, knife_deps, options)
    end
  end
end

#get_modified_cookbooks(options, paths = repo_cookbook_paths) ⇒ Object 



135
136
137
138
139
140
141
142
 
# File 'lib/fhcap/repos_helper.rb', line 135

def get_modified_cookbooks(options, paths=repo_cookbook_paths)
  modified = []
  cookbook_loader(paths).cookbook_names.each do |name|
    cookbook_dir = cookbook_loader.cookbooks_by_name[name].root_dir
    modified << name if modified?(cookbook_dir, options[:'base-branch'] || 'origin/master')
  end
  modified
end

#git_diff(file, options = '--shortstat') ⇒ Object 



201
202
203
204
205
 
# File 'lib/fhcap/repos_helper.rb', line 201

def git_diff(file, options='--shortstat')
  Dir.chdir(File.dirname(file)) do
    `git diff #{options} #{file}`
  end
end

#is_dirty?(file) ⇒ Boolean

Returns:

  • (Boolean) 


194
195
196
197
198
199
 
# File 'lib/fhcap/repos_helper.rb', line 194

def is_dirty?(file)
  stat = Dir.chdir(File.dirname(file)) do
    `git status #{file} --porcelain`
  end
  !stat.empty?
end

#modified?(path, since = 'origin/master') ⇒ Boolean

Returns:

  • (Boolean) 


187
188
189
190
191
192
 
# File 'lib/fhcap/repos_helper.rb', line 187

def modified?(path, since='origin/master')
  stat = Dir.chdir(path) do
    `git diff #{since} -- #{path}`
  end
  !stat.empty?
end

#repo_cfg(name) ⇒ Object 



19
20
21
22
 
# File 'lib/fhcap/repos_helper.rb', line 19

def repo_cfg(name)
  name = name.to_sym
  repos_config[name]
end

#repo_clusters_dir(name) ⇒ Object 



36
37
38
39
40
41
 
# File 'lib/fhcap/repos_helper.rb', line 36

def repo_clusters_dir(name)
  name = name.to_sym
  if repos_config[name]
    repos_config[name][:clusters_dir] || 'clusters'
  end
end

#repo_cookbook_paths(dir_query = 'cookbooks') ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/fhcap/repos_helper.rb', line 98

def repo_cookbook_paths(dir_query='cookbooks')
  @repo_cookbook_paths = {} unless @repo_cookbook_paths
  unless @repo_cookbook_paths[dir_query]
    @repo_cookbook_paths[dir_query] = []
    repo_paths.each do |repo_dir|
      thor.inside(repo_dir) do
        Dir.glob('*').each do |f|
          if f && File.directory?(f) && f =~ /#{dir_query}/
            @repo_cookbook_paths[dir_query] << File.join(repo_dir, f)
          end
        end
      end
    end
  end
  @repo_cookbook_paths[dir_query]
end

#repo_dir(name) ⇒ Object 



12
13
14
15
16
17
 
# File 'lib/fhcap/repos_helper.rb', line 12

def repo_dir(name)
  name = name.to_sym
  if repos_config[name]
    File.join(repos_dir, name.to_s)
  end
end

#repo_names ⇒ Object 



30
31
32
33
34
 
# File 'lib/fhcap/repos_helper.rb', line 30

def repo_names
  repos_config.collect do |name, cfg|
    name.to_s
  end
end

#repo_paths ⇒ Object 



24
25
26
27
28
 
# File 'lib/fhcap/repos_helper.rb', line 24

def repo_paths
  repos_config.collect do |name, cfg|
    repo_dir(name)
  end
end

#repos_config ⇒ Object 



4
5
6
 
# File 'lib/fhcap/repos_helper.rb', line 4

def repos_config
  config.exists? && config[:repos] ? config[:repos] : {}
end

#repos_dir ⇒ Object 



8
9
10
 
# File 'lib/fhcap/repos_helper.rb', line 8

def repos_dir
  config[:repos_dir] || config.default_dir
end

#run_inside_repo_dir(repo_dir, cmd) ⇒ Object 



43
44
45
46
47
48
49
50
 
# File 'lib/fhcap/repos_helper.rb', line 43

def run_inside_repo_dir(repo_dir, cmd)
  status = -1
  thor.inside(repo_dir) do
    thor.run(cmd, :capture => !@verbose)
    status = $?.exitstatus
  end
  status == 0
end