Class: Ridley::Client

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Celluloid, Logging
Defined in:
lib/ridley/client.rb

Defined Under Namespace

Classes: ConnectionSupervisor, ResourcesSupervisor

Constant Summary collapse

REQUIRED_OPTIONS = 
[
  :server_url,
  :client_name,
  :client_key
].freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Logging

logger, #logger, set_logger

Constructor Details

#initialize(options = {}) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :server_url (String) —

    URL to the Chef API

  • :client_name (String) —

    name of the client used to authenticate with the Chef API

  • :client_key (String) —

    filepath to the client’s private key used to authenticate with the Chef API

  • :validator_client (String) — default: nil
  • :validator_path (String) — default: nil
  • :encrypted_data_bag_secret_path (String) — default: nil
  • :ssh (Hash) — default: Hash.new —

    • :user (String) a shell user that will login to each node and perform the bootstrap command on (required)

    • :password (String) the password for the shell user that will perform the bootstrap

    • :keys (Array, String) an array of keys (or a single key) to authenticate the ssh user with instead of a password

    • :timeout (Float) [5.0] timeout value for SSH bootstrap

    • :sudo (Boolean) [true] bootstrap with sudo

  • :winrm (Hash) — default: Hash.new —

    • :user (String) a user that will login to each node and perform the bootstrap command on (required)

    • :password (String) the password for the user that will perform the bootstrap

    • :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)

  • :chef_version (String) —

    the version of Chef to use when bootstrapping

  • :params (Hash) —

    URI query unencoded key/value pairs

  • :headers (Hash) —

    unencoded HTTP header key/value pairs

  • :request (Hash) —

    request options

  • :ssl (Hash) —

    • :verify (Boolean) [true] set to false to disable SSL verification

  • :proxy (URI, String, Hash) —

    URI, String, or Hash of HTTP proxy options

  • :pool_size (Integer) — default: 4 —

    size of the connection pool

Raises:



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/ridley/client.rb', line 129

def initialize(options = {})
  @options = options.reverse_merge(
    ssh: Hash.new,
    winrm: Hash.new,
    pool_size: 4
  ).deep_symbolize_keys
  self.class.validate_options(@options)

  @ssh              = @options[:ssh]
  @winrm            = @options[:winrm]
  @chef_version     = @options[:chef_version]
  @validator_client = @options[:validator_client]

  @options[:client_key] = File.expand_path(@options[:client_key])

  if @options[:validator_path]
    @validator_path = File.expand_path(@options[:validator_path])
  end

  if @options[:encrypted_data_bag_secret_path]
    @encrypted_data_bag_secret_path = File.expand_path(@options[:encrypted_data_bag_secret_path])
  end

  @options[:encrypted_data_bag_secret] = encrypted_data_bag_secret

  unless @options[:client_key].present? && File.exist?(@options[:client_key])
    raise Errors::ClientKeyFileNotFound, "client key not found at: '#{@options[:client_key]}'"
  end

  @connection_registry   = Celluloid::Registry.new
  @resources_registry    = Celluloid::Registry.new
  @connection_supervisor = ConnectionSupervisor.new(@connection_registry, @options)
  @resources_supervisor  = ResourcesSupervisor.new(@resources_registry, @connection_registry, @options)
end

Instance Attribute Details

#chef_version ⇒ Object

Returns the value of attribute chef_version.



91
92
93
 
# File 'lib/ridley/client.rb', line 91

def chef_version
  @chef_version
end

#encrypted_data_bag_secret_path ⇒ Object

Returns the value of attribute encrypted_data_bag_secret_path.



88
89
90
 
# File 'lib/ridley/client.rb', line 88

def encrypted_data_bag_secret_path
  @encrypted_data_bag_secret_path
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



84
85
86
 
# File 'lib/ridley/client.rb', line 84

def options
  @options
end

#ssh ⇒ Object

Returns the value of attribute ssh.



89
90
91
 
# File 'lib/ridley/client.rb', line 89

def ssh
  @ssh
end

#validator_client ⇒ Object

Returns the value of attribute validator_client.



86
87
88
 
# File 'lib/ridley/client.rb', line 86

def validator_client
  @validator_client
end

#validator_path ⇒ Object

Returns the value of attribute validator_path.



87
88
89
 
# File 'lib/ridley/client.rb', line 87

def validator_path
  @validator_path
end

#winrm ⇒ Object

Returns the value of attribute winrm.



90
91
92
 
# File 'lib/ridley/client.rb', line 90

def winrm
  @winrm
end

Class Method Details

.open(options = {}, &block) ⇒ Object 



33
34
35
36
37
38
 
# File 'lib/ridley/client.rb', line 33

def open(options = {}, &block)
  client = new(options)
  yield client
ensure
  client.terminate if client && client.alive?
end

.validate_options(options) ⇒ Boolean

Returns:

  • (Boolean)

Raises:

  • (ArgumentError) 


43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/ridley/client.rb', line 43

def validate_options(options)
  missing = (REQUIRED_OPTIONS - options.keys)

  if missing.any?
    missing.collect! { |opt| "'#{opt}'" }
    raise ArgumentError, "Missing required option(s): #{missing.join(', ')}"
  end

  missing_values = options.slice(*REQUIRED_OPTIONS).select { |key, value| !value.present? }
  if missing_values.any?
    values = missing_values.keys.collect { |opt| "'#{opt}'" }
    raise ArgumentError, "Missing value for required option(s): '#{values.join(', ')}'"
  end
end

Instance Method Details

#client ⇒ Ridley::ClientResource

Returns:



165
166
167
 
# File 'lib/ridley/client.rb', line 165

def client
  @resources_registry[:client_resource]
end

#cookbook ⇒ Ridley::CookbookResource

Returns:



170
171
172
 
# File 'lib/ridley/client.rb', line 170

def cookbook
  @resources_registry[:cookbook_resource]
end

#data_bag ⇒ Ridley::DataBagResource

Returns:



175
176
177
 
# File 'lib/ridley/client.rb', line 175

def data_bag
  @resources_registry[:data_bag_resource]
end

#encrypted_data_bag_secret ⇒ String?

The encrypted data bag secret for this connection.

Returns:

  • (String, nil)

Raises:



233
234
235
236
237
238
239
 
# File 'lib/ridley/client.rb', line 233

def encrypted_data_bag_secret
  return nil if encrypted_data_bag_secret_path.nil?

  ::IO.read(encrypted_data_bag_secret_path).chomp
rescue Errno::ENOENT => e
  raise Errors::EncryptedDataBagSecretNotFound, "Encrypted data bag secret provided but not found at '#{encrypted_data_bag_secret_path}'"
end

#environment ⇒ Ridley::EnvironmentResource

Returns:



180
181
182
 
# File 'lib/ridley/client.rb', line 180

def environment
  @resources_registry[:environment_resource]
end

#node ⇒ Ridley::NodeResource

Returns:



185
186
187
 
# File 'lib/ridley/client.rb', line 185

def node
  @resources_registry[:node_resource]
end

#role ⇒ Ridley::RoleResource

Returns:



190
191
192
 
# File 'lib/ridley/client.rb', line 190

def role
  @resources_registry[:role_resource]
end

#sandbox ⇒ Ridley::SandboxResource

Returns:



195
196
197
 
# File 'lib/ridley/client.rb', line 195

def sandbox
  @resources_registry[:sandbox_resource]
end

#search(index, query = nil, options = {}) ⇒ Hash

Perform a search the Chef Server

Parameters:

  • index (#to_sym, #to_s)
  • query_string (#to_s)
  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :sort (String) —

    a sort string such as ‘name DESC’

  • :rows (Integer) —

    how many rows to return

  • :start (Integer) —

    the result number to start from

Returns:

  • (Hash) 


212
213
214
 
# File 'lib/ridley/client.rb', line 212

def search(index, query = nil, options = {})
  @resources_registry[:search_resource].run(index, query, @resources_registry, options)
end

#search_indexes ⇒ Array<Symbol, String>

Return the array of all possible search indexes for the including connection

Examples:

conn = Ridley.new(...)
conn.search_indexes =>
  [:client, :environment, :node, :role, :"ridley-two", :"ridley-one"]

Returns:

  • (Array<Symbol, String>) 


224
225
226
 
# File 'lib/ridley/client.rb', line 224

def search_indexes
  @resources_registry[:search_resource].indexes
end

#server_url ⇒ Object 



241
242
243
 
# File 'lib/ridley/client.rb', line 241

def server_url
  self.url_prefix.to_s
end