Class: Collins::Asset

Inherits:
Object
  • Object
show all
Includes:
Find, Update, Util
Defined in:
lib/collins/asset.rb,
lib/collins/asset_find.rb,
lib/collins/asset_update.rb

Overview

Represents the basic notion of a collins asset

Defined Under Namespace

Modules: Find, Update

Constant Summary collapse

DATETIME_FORMAT =

Default time format when displaying dates associated with an asset

"%F %T"

Constants included from Util::Logging

Util::Logging::DEFAULT_LOG_FORMAT

Constants included from Update

Update::ALL_PARAMS, Update::FILE_PARAMS, Update::NON_ATTRIBUTE_PARAMS

Constants included from Find

Find::ALL_PARAMS, Find::DATE_PARAMS, Find::GENERAL_PARAMS

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Util

#deep_copy_hash, #get_asset_or_tag, included, #require_non_empty, #require_that, #stringify_hash, #symbolize_hash

Methods included from Util::Logging

#get_logger

Methods included from Update

get_param, get_param_value, is_attribute?, is_file_param?, to_a

Methods included from Find

to_a, valid?

Constructor Details

#initialize(opts = {}) ⇒ Asset

Create an Asset

Options Hash (opts):

  • :tag (String) —

    The asset tag

  • :created (String) —

    The creation DateTime

  • :id (Fixnum) —

    The ID of the asset

  • :status (String) —

    The asset status

  • :type (String) —

    The asset type

  • :updated (String) —

    The update DateTime

  • :deleted (String) —

    The delete DateTime



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/collins/asset.rb', line 87

def initialize opts = {}
  @extras = {}
  @addresses = []
  if opts.is_a?(String) then
    model = {:tag => opts}
  else
    model = opts
  end
  hash = symbolize_hash(model).inject({}) do |result, (k,v)|
    result[k.downcase] = v
    result
  end
  @created = parse_datetime hash.delete(:created).to_s
  @id = hash.delete(:id).to_s.to_i
  @status = hash.delete(:status).to_s
  @tag = hash.delete(:tag).to_s
  @type = hash.delete(:type).to_s
  @state = Collins::AssetState.from_json(hash.delete(:state))
  @updated = parse_datetime hash.delete(:updated).to_s
  @deleted = parse_datetime hash.delete(:deleted).to_s
  hash.each {|k,v| @extras[k] = v}
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *args, &block) ⇒ NilClass, Object (protected)

Note:

This is never called directly

Convenience method for #get_attribute

This ‘magic’ method allows you to retrieve attributes on an asset, or check if an attribute exists via a predicate method.

Examples:

real_asset.hostname # => "foo"
bare_asset.hostname # => nil
real_asset.hostname? # => true
bare_asset.hostname? # => false


251
252
253
254
255
256
257
258
259
260
 
# File 'lib/collins/asset.rb', line 251

def method_missing(m, *args, &block)
  name = m.to_s.upcase
  is_bool = name.end_with?('?')
  if is_bool then
    name = name.sub('?', '')
    respond_to?(name)
  else
    extract(extras, "ATTRIBS", "0", name)
  end
end

Instance Attribute Details

#addresses ⇒ Array<CollinsAddress> 



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

def addresses
  @addresses
end

#created ⇒ DateTime, NilClass 



26
27
28
 
# File 'lib/collins/asset.rb', line 26

def created
  @created
end

#deleted ⇒ DateTime, NilClass (readonly) 



26
27
28
 
# File 'lib/collins/asset.rb', line 26

def deleted
  @deleted
end

#extras ⇒ Hash 



44
45
46
 
# File 'lib/collins/asset.rb', line 44

def extras
  @extras
end

#id ⇒ Fixnum 



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

def id
  @id
end

#ipmi ⇒ Collins::Ipmi 



30
31
32
 
# File 'lib/collins/asset.rb', line 30

def ipmi
  @ipmi
end

#location ⇒ String 



32
33
34
 
# File 'lib/collins/asset.rb', line 32

def location
  @location
end

#power ⇒ Collins::Power 



34
35
36
 
# File 'lib/collins/asset.rb', line 34

def power
  @power
end

#state ⇒ Collins::AssetState 



36
37
38
 
# File 'lib/collins/asset.rb', line 36

def state
  @state
end

#status ⇒ String 



38
39
40
 
# File 'lib/collins/asset.rb', line 38

def status
  @status
end

#tag ⇒ String 



40
41
42
 
# File 'lib/collins/asset.rb', line 40

def tag
  @tag
end

#type ⇒ String 



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

def type
  @type
end

#updated ⇒ DateTime, NilClass 



26
27
28
 
# File 'lib/collins/asset.rb', line 26

def updated
  @updated
end

Class Method Details

.format_date_string(s) ⇒ DateTime

Convenience method for parsing asset ISO8601 date times



72
73
74
75
 
# File 'lib/collins/asset.rb', line 72

def format_date_string s
  parsed = DateTime.parse(s)
  parsed.strftime("%FT%T")
end

.from_json(json_hash, bare_asset = false) ⇒ Collins::Asset

Given a Hash deserialized from JSON, convert to an Asset

Raises:



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/collins/asset.rb', line 52

def from_json json_hash, bare_asset = false
  (raise Collins::CollinsError.new("Invalid JSON specified for Asset.from_json")) if (json_hash.nil? || !json_hash.is_a?(Hash))
  json = deep_copy_hash json_hash
  json = if json["data"] then json["data"] else json end
  if bare_asset or !json.include?("ASSET") then
    asset = Collins::Asset.new json
  else
    asset = Collins::Asset.new json.delete("ASSET")
  end
  asset.send('ipmi='.to_sym, Collins::Ipmi.from_json(json.delete("IPMI")))
  asset.send('addresses='.to_sym, Collins::Address.from_json(json.delete("ADDRESSES")))
  asset.send('power='.to_sym, Collins::Power.from_json(json.delete("POWER")))
  asset.send('location=', json.delete("LOCATION"))
  asset.send('extras=', json)
  asset
end

Instance Method Details

#backend_address ⇒ Collins::Address, NilClass 



111
112
113
 
# File 'lib/collins/asset.rb', line 111

def backend_address
  backend_addresses.first if backend_address?
end

#backend_address? ⇒ Boolean 



115
116
117
 
# File 'lib/collins/asset.rb', line 115

def backend_address?
  backend_addresses.length > 0
end

#backend_addresses ⇒ Array<Collins::Address> 



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

def backend_addresses
  addresses.select{|a| a.is_private?}
end

#backend_ip_address ⇒ String, NilClass

Deprecated.

Users are encouraged to use #backend_address

Returns Address of first available backend address.



125
126
127
 
# File 'lib/collins/asset.rb', line 125

def backend_ip_address
  backend_address.address if backend_address?
end

#backend_ip_addresses ⇒ Array<String>

Deprecated.

Users are encouraged to uses #backend_addresses

Returns Backend IP addresses.



130
131
132
 
# File 'lib/collins/asset.rb', line 130

def backend_ip_addresses
  backend_addresses.map{|a| a.address}
end

#backend_netmask ⇒ String, NilClass 



159
160
161
 
# File 'lib/collins/asset.rb', line 159

def backend_netmask
  backend_address.netmask if backend_address?
end

#backend_netmasks ⇒ Array<String> 



163
164
165
 
# File 'lib/collins/asset.rb', line 163

def backend_netmasks
  backend_addresses.map{|i| i.netmask}
end

#cpu_count ⇒ Fixnum 



188
189
190
 
# File 'lib/collins/asset.rb', line 188

def cpu_count
  (extract(extras, "HARDWARE", "CPU") || []).length
end

#cpus ⇒ Array<Hash> 



192
193
194
 
# File 'lib/collins/asset.rb', line 192

def cpus
  extract(extras, "HARDWARE", "CPU") || []
end

#disks ⇒ Array<Hash> 



197
198
199
 
# File 'lib/collins/asset.rb', line 197

def disks
  extract(extras, "HARDWARE", "DISK") || []
end

#gateway_address(pool = "default") ⇒ String

Note:

If there is no address in the specified pool, the gateway of the first usable address is

Return the gateway address for the specified pool, or the first gateway used, which may not be desired.



172
173
174
175
176
177
178
179
180
 
# File 'lib/collins/asset.rb', line 172

def gateway_address pool = "default"
  address = addresses.select{|a| a.pool == pool}.map{|a| a.gateway}.first
  return address if address
  if addresses.length > 0 then
    addresses.first.gateway
  else
    nil
  end
end

#get_attribute(name) ⇒ Object, NilClass 



183
184
185
 
# File 'lib/collins/asset.rb', line 183

def get_attribute name
  extract(extras, "ATTRIBS", "0", name.to_s.upcase)
end

#mac_addresses ⇒ Array<String> 



214
215
216
 
# File 'lib/collins/asset.rb', line 214

def mac_addresses
  nics.map{|n| n["MAC_ADDRESS"]}.select{|a| !a.nil?}
end

#memory ⇒ Array<Hash> 



201
202
203
 
# File 'lib/collins/asset.rb', line 201

def memory
  extract(extras, "HARDWARE", "MEMORY") || []
end

#nics ⇒ Array<Hash> 



206
207
208
 
# File 'lib/collins/asset.rb', line 206

def nics
  extract(extras, "HARDWARE", "NIC") || []
end

#physical_nic_count ⇒ Fixnum 



210
211
212
 
# File 'lib/collins/asset.rb', line 210

def physical_nic_count
  nics.length
end

#public_address ⇒ Collins::Address, NilClass 



135
136
137
 
# File 'lib/collins/asset.rb', line 135

def public_address
  public_addresses.first if public_address?
end

#public_address? ⇒ Boolean 



139
140
141
 
# File 'lib/collins/asset.rb', line 139

def public_address?
  public_addresses.length > 0
end

#public_addresses ⇒ Array<Collins::Address> 



143
144
145
 
# File 'lib/collins/asset.rb', line 143

def public_addresses
  addresses.select{|a| a.is_public?}
end

#public_ip_address ⇒ String, NilClass

Deprecated.

Users are encouraged to use #public_address

Returns Address of first available public address.



149
150
151
 
# File 'lib/collins/asset.rb', line 149

def public_ip_address
  public_address.address if public_address?
end

#public_ip_addresses ⇒ Array<String>

Deprecated.

Users are encouraged to uses #public_addresses

Returns Public IP addresses.



154
155
156
 
# File 'lib/collins/asset.rb', line 154

def public_ip_addresses
  public_addresses.map{|a| a.address}
end

#respond_to?(name) ⇒ Boolean 



226
227
228
229
230
231
232
 
# File 'lib/collins/asset.rb', line 226

def respond_to? name
  if extract(extras, "ATTRIBS", "0", name.to_s.upcase).nil? then
    super
  else
    true
  end
end

#to_s ⇒ String 



219
220
221
222
223
224
 
# File 'lib/collins/asset.rb', line 219

def to_s
  updated_t = format_datetime(updated, "Never")
  created_t = format_datetime(created, "Never")
  ipmi_i = ipmi.nil? ? "No IPMI Data" : ipmi.to_s
  "Asset(id = #{id}, tag = #{tag}, status = #{status}, type = #{type}, created = #{created_t}, updated = #{updated_t}, ipmi = #{ipmi_i}, state = #{state.to_s})"
end