Module: Cheffish

Defined in:
lib/cheffish.rb,
lib/cheffish/rspec.rb,
lib/cheffish/version.rb,
lib/cheffish/chef_run.rb,
lib/cheffish/server_api.rb,
lib/cheffish/with_pattern.rb,
lib/cheffish/base_resource.rb,
lib/cheffish/chef_run_data.rb,
lib/cheffish/key_formatter.rb,
lib/cheffish/merged_config.rb,
lib/cheffish/array_property.rb,
lib/cheffish/base_properties.rb,
lib/cheffish/chef_actor_base.rb,
lib/cheffish/node_properties.rb,
lib/cheffish/basic_chef_client.rb,
lib/cheffish/chef_run_listener.rb,
lib/cheffish/rspec/chef_run_support.rb,
lib/cheffish/rspec/recipe_run_wrapper.rb,
lib/cheffish/rspec/repository_support.rb,
lib/cheffish/rspec/matchers/partially_match.rb

Defined Under Namespace

Modules: BaseProperties, NodeProperties, RSpec, WithPattern Classes: ArrayProperty, BaseResource, BasicChefClient, ChefActorBase, ChefRun, ChefRunData, ChefRunListener, KeyFormatter, MergedConfig, ServerAPI

Constant Summary collapse

NAME_REGEX = 
/^[.\-[:alnum:]_]+$/.freeze
VERSION = 
"17.1.8".freeze

Class Method Summary collapse

Class Method Details

.chef_server_api(chef_server = default_chef_server) ⇒ Object 



18
19
20
21
22
23
24
 
# File 'lib/cheffish.rb', line 18

def self.chef_server_api(chef_server = default_chef_server)
  # Pin the server api version to 0 until https://github.com/chef/cheffish/issues/56
  # gets the correct compatibility fix.
  chef_server[:options] ||= {}
  chef_server[:options][:api_version] = "0"
  Cheffish::ServerAPI.new(chef_server[:chef_server_url], chef_server[:options])
end

.default_chef_server(config = profiled_config) ⇒ Object 



8
9
10
11
12
13
14
15
16
 
# File 'lib/cheffish.rb', line 8

def self.default_chef_server(config = profiled_config)
  {
    chef_server_url: config[:chef_server_url],
    options: {
      client_name: config[:node_name],
      signing_key_filename: config[:client_key],
    },
  }
end

.get_private_key(name, config = profiled_config) ⇒ Object 



85
86
87
88
 
# File 'lib/cheffish.rb', line 85

def self.get_private_key(name, config = profiled_config)
  key, _key_path = get_private_key_with_path(name, config)
  key
end

.get_private_key_with_path(name, config = profiled_config) ⇒ Object 



90
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
 
# File 'lib/cheffish.rb', line 90

def self.get_private_key_with_path(name, config = profiled_config)
  if config[:private_keys] && config[:private_keys][name]
    named_key = config[:private_keys][name]
    if named_key.is_a?(String)
      Chef::Log.info("Got key #{name} from Chef::Config.private_keys.#{name}, which points at #{named_key}.  Reading key from there ...")
      return [ IO.read(named_key), named_key]
    else
      Chef::Log.info("Got key #{name} raw from Chef::Config.private_keys.#{name}.")
      return [ named_key.to_pem, nil ]
    end
  elsif config[:private_key_paths]
    config[:private_key_paths].each do |private_key_path|
      next unless File.exist?(private_key_path)

      Dir.entries(private_key_path).sort.each do |key|
        ext = File.extname(key)
        if key == name || ext == "" || ext == ".pem"
          key_name = key[0..-(ext.length + 1)]
          if key_name == name || key == name
            Chef::Log.info("Reading key #{name} from file #{private_key_path}/#{key}")
            return [ IO.read("#{private_key_path}/#{key}"), "#{private_key_path}/#{key}" ]
          end
        end
      end
    end
  end
  nil
end

.honor_local_mode(local_mode_default = true, &block) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/cheffish.rb', line 62

def self.honor_local_mode(local_mode_default = true, &block)
  if !Chef::Config.key?(:local_mode) && !local_mode_default.nil?
    Chef::Config.local_mode = local_mode_default
  end
  if Chef::Config.local_mode && !Chef::Config.key?(:cookbook_path) && !Chef::Config.key?(:chef_repo_path)
    Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
  end
  begin
    require "chef/local_mode"
    Chef::LocalMode.with_server_connectivity(&block)

  rescue LoadError
    Chef::Application.setup_server_connectivity
    if block_given?
      begin
        yield
      ensure
        Chef::Application.destroy_server_connectivity
      end
    end
  end
end

.inline_resource(provider, provider_action, *resources, &block) ⇒ Object 



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

def self.inline_resource(provider, provider_action, *resources, &block)
  BasicChefClient.inline_resource(provider, provider_action, *resources, &block)
end

.load_chef_config(chef_config = Chef::Config) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/cheffish.rb', line 34

def self.load_chef_config(chef_config = Chef::Config)
  chef_config.config_file = if ::Gem::Version.new(::Chef::VERSION) >= ::Gem::Version.new("12.0.0")
                              require "chef/workstation_config_loader"
                              Chef::WorkstationConfigLoader.new(nil, Chef::Log).chef_config_dir
                            else
                              require "chef/knife"
                              Chef::Knife.locate_config_file
                            end
  config_fetcher = Chef::ConfigFetcher.new(chef_config.config_file, chef_config.config_file_jail)
  if chef_config.config_file.nil?
    Chef::Log.warn("No config file found or specified on command line, using command line options.")
  elsif config_fetcher.config_missing?
    Chef::Log.warn("Did not find config file: #{chef_config.config_file}, using command line options.")
  else
    config_content = config_fetcher.read_config
    config_file_path = chef_config.config_file
    begin
      chef_config.from_string(config_content, config_file_path)
    rescue Exception => error
      Chef::Log.fatal("Configuration error #{error.class}: #{error.message}")
      filtered_trace = error.backtrace.grep(/#{Regexp.escape(config_file_path)}/)
      filtered_trace.each { |line| Chef::Log.fatal("  " + line ) }
      Chef::Application.fatal!("Aborting due to error in '#{config_file_path}'", 2)
    end
  end
  Cheffish.profiled_config(chef_config)
end

.node_attributes(klass) ⇒ Object 



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

def self.node_attributes(klass)
  klass.include Cheffish::NodeProperties
end

.profiled_config(config = Chef::Config) ⇒ Object 



26
27
28
29
30
31
32
 
# File 'lib/cheffish.rb', line 26

def self.profiled_config(config = Chef::Config)
  if config.profile && config.profiles && config.profiles[config.profile]
    MergedConfig.new(config.profiles[config.profile], config)
  else
    config
  end
end