Class: IronCore::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/iron_core/client.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(company, product, options = {}, default_options = {}, extra_options_list = []) ⇒ Client

Returns a new instance of Client.



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/iron_core/client.rb', line 13

def initialize(company, product, options = {}, default_options = {}, extra_options_list = [])
  @options_list = [:scheme, :host, :port, :user_agent, :http_gem, :keystone, :http_proxy] + extra_options_list

  metaclass = class << self
    self
  end

  @options_list.each do |option|
    instance_variable_set('@' + option.to_s, nil)

    metaclass.send(:define_method, option.to_s) do
      instance_variable_get('@' + option.to_s)
    end

    metaclass.send(:define_method, option.to_s + '=') do |value|
      instance_variable_set('@' + option.to_s, value)
    end
  end

  @env = options[:env] || options['env']
  @env ||= ENV[company.upcase + '_' + product.upcase + '_ENV'] || ENV[company.upcase + '_ENV']

  IronCore::Logger.debug 'IronCore', "Setting env to '#{@env}'" unless @env.nil?

  load_from_hash('params', options)

  load_from_config(company, product, options[:config] || options['config'])

  load_from_config(company, product, ENV[company.upcase + '_' + product.upcase + '_CONFIG'])
  load_from_config(company, product, ENV[company.upcase + '_CONFIG'])

  load_from_env(company.upcase + '_' + product.upcase)
  load_from_env(company.upcase)

  suffixes = []

  unless @env.nil?
    suffixes << "-#{@env}"
    suffixes << "_#{@env}"
  end

  suffixes << ''

  suffixes.each do |suffix|
    ['.json', '.yml'].each do |ext|
      ["#{company}-#{product}", "#{company}_#{product}", company].each do |config_base|
        load_from_config(company, product, "#{Dir.pwd}/#{config_base}#{suffix}#{ext}")
        load_from_config(company, product, "#{Dir.pwd}/.#{config_base}#{suffix}#{ext}")
        load_from_config(company, product, "#{Dir.pwd}/config/#{config_base}#{suffix}#{ext}")
        load_from_config(company, product, "#{Dir.pwd}/config/.#{config_base}#{suffix}#{ext}")
        begin
          load_from_config(company, product, "~/#{config_base}#{suffix}#{ext}")
          load_from_config(company, product, "~/.#{config_base}#{suffix}#{ext}")
        rescue Exception => ex
          puts "Warning -- Unable to load from HOME: #{ex.message}"
        end
      end
    end
  end

  load_from_hash('defaults', default_options)
  load_from_hash('defaults', {:user_agent => 'iron_core_ruby-' + IronCore.version})

  @content_type = 'application/json'

  default_http_gem = RUBY_VERSION.split('.')[1].to_i == 8 ? :rest_client : nil
  http_gem = @http_gem.nil? ? default_http_gem : @http_gem.to_sym

  rest_options = {:gem => http_gem}
  rest_options[:http_proxy] = options[:http_proxy] if options[:http_proxy]
  @rest = Rest::Client.new(rest_options)

  if self.keystone && self.keystone.is_a?(Hash)
    raise_keystone_config_error('server') if self.keystone[:server].nil?
    raise_keystone_config_error('tenant') if self.keystone[:tenant].nil?
    if self.keystone[:token].nil? && self.keystone[:tenant_token].nil? &&
      (self.keystone[:username].nil? && self.keystone[:password].nil?)
      raise_keystone_config_error('username, password or token')
    end

    @token_provider = IronCore::KeystoneTokenProvider.new(@rest, self.keystone)
  else
    @token_provider = IronCore::IronTokenProvider.new(@token)
  end
end

Instance Attribute Details

#content_type ⇒ Object

Returns the value of attribute content_type.



9
10
11
 
# File 'lib/iron_core/client.rb', line 9

def content_type
  @content_type
end

#env ⇒ Object

Returns the value of attribute env.



10
11
12
 
# File 'lib/iron_core/client.rb', line 10

def env
  @env
end

#rest ⇒ Object (readonly)

Returns the value of attribute rest.



11
12
13
 
# File 'lib/iron_core/client.rb', line 11

def rest
  @rest
end

Instance Method Details

#base_url ⇒ Object 



198
199
200
 
# File 'lib/iron_core/client.rb', line 198

def base_url
  "#{scheme}://#{host}:#{port}/"
end

#check_id(id, name = 'id', length = 24) ⇒ Object 



343
344
345
346
347
 
# File 'lib/iron_core/client.rb', line 343

def check_id(id, name = 'id', length = 24)
  if (not id.is_a?(String)) || id.length != length
    IronCore::Logger.error 'IronCore', "Expecting #{length} symbol #{name} string", IronCore::Error
  end
end

#delete(method, params = {}, headers2 = {}) ⇒ Object 



277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
 
# File 'lib/iron_core/client.rb', line 277

def delete(method, params = {}, headers2={})
  request_hash = {}
  request_hash[:headers] = headers.merge(headers2)
  if params.size > 0
    request_hash[:headers].merge!({'Content-Type' => @content_type})
  end
  request_hash[:body] = params.to_json

  IronCore::Logger.debug 'IronCore', "DELETE #{base_url + method} with params='#{request_hash.to_s}'"

  begin
  @rest.delete(base_url + method, request_hash)
  rescue Rest::HttpError => ex
    extract_error_msg(ex)
  end
end

#extract_error_msg(ex) ⇒ Object 



220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/iron_core/client.rb', line 220

def extract_error_msg(ex)
  if ex.response && ex.response.body
    begin
      bodyparsed = JSON.parse(ex.response.body)
      msg = bodyparsed["msg"]
      if msg
        ex.msg = msg
      end
    rescue => ex2
      # ignore
    end
  end
  raise ex
end

#get(method, params = {}) ⇒ Object 



206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/iron_core/client.rb', line 206

def get(method, params = {})
  request_hash = {}
  request_hash[:headers] = headers
  request_hash[:params] = params

  IronCore::Logger.debug 'IronCore', "GET #{url(method)} with params='#{request_hash.to_s}'"

  begin
    @rest.get(url(method), request_hash)
  rescue Rest::HttpError => ex
    extract_error_msg(ex)
  end
end

#get_sub_hash(hash, subs) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/iron_core/client.rb', line 130

def get_sub_hash(hash, subs)
  return nil if hash.nil?

  subs.each do |sub|
    return nil if hash[sub].nil?

    hash = hash[sub]
  end

  hash
end

#headers ⇒ Object 



194
195
196
 
# File 'lib/iron_core/client.rb', line 194

def headers
  {'User-Agent' => @user_agent}
end

#load_from_config(company, product, config_file) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/iron_core/client.rb', line 142

def load_from_config(company, product, config_file)
  return if config_file.nil?

  if File.exist?(File.expand_path(config_file))
    config_data = '{}'

    begin
      config_data = File.read(File.expand_path(config_file))
    rescue
      return
    end

    config = nil

    if config_file.end_with?('.yml')
      config = YAML.load(config_data)
    else
      config = JSON.parse(config_data)
    end

    unless @env.nil?
      load_from_hash(config_file, get_sub_hash(config, [@env, "#{company}_#{product}"]))
      load_from_hash(config_file, get_sub_hash(config, [@env, company, product]))
      load_from_hash(config_file, get_sub_hash(config, [@env, product]))
      load_from_hash(config_file, get_sub_hash(config, [@env, company]))

      load_from_hash(config_file, get_sub_hash(config, ["#{company}_#{product}", @env]))
      load_from_hash(config_file, get_sub_hash(config, [company, product, @env]))
      load_from_hash(config_file, get_sub_hash(config, [product, @env]))
      load_from_hash(config_file, get_sub_hash(config, [company, @env]))

      load_from_hash(config_file, get_sub_hash(config, [@env]))
    end

    load_from_hash(config_file, get_sub_hash(config, ["#{company}_#{product}"]))
    load_from_hash(config_file, get_sub_hash(config, [company, product]))
    load_from_hash(config_file, get_sub_hash(config, [product]))
    load_from_hash(config_file, get_sub_hash(config, [company]))
    load_from_hash(config_file, get_sub_hash(config, []))
  end
end

#load_from_env(prefix) ⇒ Object 



124
125
126
127
128
 
# File 'lib/iron_core/client.rb', line 124

def load_from_env(prefix)
  @options_list.each do |o|
    set_option('environment variable', o, ENV[prefix + '_' + o.to_s.upcase])
  end
end

#load_from_hash(source, hash) ⇒ Object 



116
117
118
119
120
121
122
 
# File 'lib/iron_core/client.rb', line 116

def load_from_hash(source, hash)
  return if hash.nil?

  @options_list.each do |o|
    set_option(source, o, hash[o.to_sym] || hash[o.to_s])
  end
end

#options(return_strings = false) ⇒ Object 



184
185
186
187
188
189
190
191
192
 
# File 'lib/iron_core/client.rb', line 184

def options(return_strings = false)
  res = {}

  @options_list.each do |option|
    res[return_strings ? option.to_s : option.to_sym] = send(option.to_s)
  end

  res
end

#parse_response(response, parse_json = true) ⇒ Object

Raises:



331
332
333
334
335
336
337
338
339
340
341
 
# File 'lib/iron_core/client.rb', line 331

def parse_response(response, parse_json = true)
  IronCore::Logger.debug 'IronCore', "GOT #{response.code} with params='#{response.body}'"

  raise IronCore::ResponseError.new(response) if (response.code < 200 || response.code >= 300)

  body = String.new(response.body)

  return body unless parse_json

  JSON.parse(body)
end

#patch(method, params = {}) ⇒ Object 



263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/iron_core/client.rb', line 263

def patch(method, params={})
  request_hash = {}
  request_hash[:headers] = headers.merge({'Content-Type' => @content_type})
  request_hash[:body] = params.to_json

  IronCore::Logger.debug 'IronCore', "PUT #{base_url + method} with params='#{request_hash.to_s}'"

  begin
    @rest.patch(base_url + method, request_hash)
  rescue Rest::HttpError => ex
    extract_error_msg(ex)
  end
end

#post(method, params = {}) ⇒ Object 



235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/iron_core/client.rb', line 235

def post(method, params = {})
  request_hash = {}
  request_hash[:headers] = headers.merge({'Content-Type' => @content_type})
  request_hash[:body] = params.to_json

  IronCore::Logger.debug 'IronCore', "POST #{base_url + method} with params='#{request_hash.to_s}'"

  begin
    @rest.post(base_url + method, request_hash)
  rescue Rest::HttpError => ex
    extract_error_msg(ex)
  end
end

#post_file(method, file_field, file, params_field, params = {}) ⇒ Object 



294
295
296
297
298
299
300
301
302
303
304
305
306
 
# File 'lib/iron_core/client.rb', line 294

def post_file(method, file_field, file, params_field, params = {})
  request_hash = {}
  request_hash[:headers] = headers
  request_hash[:body] = {params_field => params.to_json, file_field => file}

  IronCore::Logger.debug 'IronCore', "POST #{base_url + method} with params='#{request_hash.to_s}'"

  begin
  @rest.post_file(base_url + method, request_hash)
  rescue Rest::HttpError => ex
    extract_error_msg(ex)
  end
end

#put(method, params = {}) ⇒ Object 



249
250
251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/iron_core/client.rb', line 249

def put(method, params={})
  request_hash = {}
  request_hash[:headers] = headers.merge({'Content-Type' => @content_type})
  request_hash[:body] = params.to_json

  IronCore::Logger.debug 'IronCore', "PUT #{base_url + method} with params='#{request_hash.to_s}'"

  begin
    @rest.put(base_url + method, request_hash)
  rescue Rest::HttpError => ex
    extract_error_msg(ex)
  end
end

#raise_keystone_config_error(missing) ⇒ Object

Raises:



349
350
351
352
 
# File 'lib/iron_core/client.rb', line 349

def raise_keystone_config_error(missing)
  IronCore::Logger.error 'IronCore', "Keystone keys missing: #{missing}", IronCore::Error
  raise IronCore::ConfigurationError.new("Keystone keys missing: #{missing}")
end

#set_option(source, name, value) ⇒ Object 



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

def set_option(source, name, value)
  if send(name.to_s).nil? && (not value.nil?)
    if value.class == Hash
      value.keys.each do |key|
        if key.class == String
          value[key.to_sym] = value[key]
          value.delete(key)
        end
      end
    end

    IronCore::Logger.debug 'IronCore', "Setting #{name} to '#{value}' from #{source}"

    send(name.to_s + '=', value)
  end
end

#stream_get(method, params = {}) ⇒ Object 



308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
# File 'lib/iron_core/client.rb', line 308

def stream_get(method, params = {})
  request_hash = {}
  request_hash[:headers] = headers
  request_hash[:params] = params

  uri = url(method)
  unless request_hash[:params].empty?
    query_string = request_hash[:params].collect { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
    uri += "?#{query_string}"
  end

  IronCore::Logger.debug 'IronCore', "Streaming GET #{uri} with params='#{request_hash.to_s}'"

  req = URI(uri)
  Net::HTTP.start(req.hostname, req.port, :use_ssl => (req.scheme == 'https')) do |http|
    http.request_get(req.to_s, request_hash[:headers]) do |res|
      res.read_body do |chunk|
        yield(chunk)
      end
    end
  end
end

#url(method) ⇒ Object 



202
203
204
 
# File 'lib/iron_core/client.rb', line 202

def url(method)
  base_url + method
end