Class: Chef::Node

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
DSL::IncludeAttribute, DSL::PlatformIntrospection, Mixin::FromFile, Mixin::ParamsValidate
Defined in:
lib/chef/node.rb,
lib/chef/node/attribute.rb,
lib/chef/node/attribute_collections.rb,
lib/chef/node/immutable_collections.rb

Defined Under Namespace

Modules: Immutablize Classes: AttrArray, Attribute, ImmutableArray, ImmutableMash, MultiMash, VividMash

Constant Summary collapse

NULL_ARG = 
Object.new

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Mixin::ParamsValidate

#lazy, #set_or_return, #validate

Methods included from DSL::PlatformIntrospection

#platform?, #platform_family?, #value_for_platform, #value_for_platform_family

Methods included from DSL::IncludeAttribute

#include_attribute, #parse_attribute_file_spec

Methods included from Mixin::FromFile

#class_from_file, #from_file

Constructor Details

#initialize(chef_server_rest: nil) ⇒ Node

Create a new Chef::Node object.



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/chef/node.rb', line 68

def initialize(chef_server_rest: nil)
  @chef_server_rest = chef_server_rest
  @name = nil

  @chef_environment = "_default"
  @primary_runlist = Chef::RunList.new
  @override_runlist = Chef::RunList.new

  @policy_name = nil
  @policy_group = nil

  @attributes = Chef::Node::Attribute.new({}, {}, {}, {})

  @run_state = {}
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(symbol, *args) ⇒ Object

Only works for attribute fetches, setting is no longer supported



293
294
295
 
# File 'lib/chef/node.rb', line 293

def method_missing(symbol, *args)
  attributes.send(symbol, *args)
end

Instance Attribute Details

#chef_server_rest ⇒ Object

Returns the value of attribute chef_server_rest.



49
50
51
 
# File 'lib/chef/node.rb', line 49

def chef_server_rest
  @chef_server_rest
end

#override_runlist(*args) ⇒ Object

Returns the value of attribute override_runlist.



47
48
49
 
# File 'lib/chef/node.rb', line 47

def override_runlist
  @override_runlist
end

#recipe_list ⇒ Object

Returns the value of attribute recipe_list.



47
48
49
 
# File 'lib/chef/node.rb', line 47

def recipe_list
  @recipe_list
end

#run_context ⇒ Object

RunContext will set itself as run_context via this setter when initialized. This is needed so DSL::IncludeAttribute (in particular, #include_recipe) can access the run_context to determine if an attributes file has been seen yet. – TODO: This is a pretty ugly way to solve that problem.



57
58
59
 
# File 'lib/chef/node.rb', line 57

def run_context
  @run_context
end

#run_state ⇒ Object

Returns the value of attribute run_state.



47
48
49
 
# File 'lib/chef/node.rb', line 47

def run_state
  @run_state
end

Class Method Details

.build(node_name) ⇒ Object 



595
596
597
598
599
600
 
# File 'lib/chef/node.rb', line 595

def self.build(node_name)
  node = new
  node.name(node_name)
  node.chef_environment(Chef::Config[:environment]) unless Chef::Config[:environment].nil? || Chef::Config[:environment].chomp.empty?
  node
end

.find_or_create(node_name) ⇒ Object 



587
588
589
590
591
592
593
 
# File 'lib/chef/node.rb', line 587

def self.find_or_create(node_name)
  load(node_name)
rescue Net::HTTPServerException => e
  raise unless e.response.code == "404"
  node = build(node_name)
  node.create
end

.from_hash(o) ⇒ Object 



539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
 
# File 'lib/chef/node.rb', line 539

def self.from_hash(o)
  return o if o.kind_of? Chef::Node
  node = new
  node.name(o["name"])
  node.chef_environment(o["chef_environment"])
  if o.has_key?("attributes")
    node.normal_attrs = o["attributes"]
  end
  node.automatic_attrs = Mash.new(o["automatic"]) if o.has_key?("automatic")
  node.normal_attrs = Mash.new(o["normal"]) if o.has_key?("normal")
  node.default_attrs = Mash.new(o["default"]) if o.has_key?("default")
  node.override_attrs = Mash.new(o["override"]) if o.has_key?("override")

  if o.has_key?("run_list")
    node.run_list.reset!(o["run_list"])
  elsif o.has_key?("recipes")
    o["recipes"].each { |r| node.recipes << r }
  end

  node.policy_name = o["policy_name"] if o.has_key?("policy_name")
  node.policy_group = o["policy_group"] if o.has_key?("policy_group")

  node
end

.json_create(o) ⇒ Object

Create a Chef::Node from JSON



534
535
536
537
 
# File 'lib/chef/node.rb', line 534

def self.json_create(o)
  Chef.log_deprecation("Auto inflation of JSON data is deprecated. Please use Chef::Node#from_hash")
  from_hash(o)
end

.list(inflate = false) ⇒ Object 



574
575
576
577
578
579
580
581
582
583
584
585
 
# File 'lib/chef/node.rb', line 574

def self.list(inflate = false)
  if inflate
    response = Hash.new
    Chef::Search::Query.new.search(:node) do |n|
      n = Chef::Node.from_hash(n)
      response[n.name] = n unless n.nil?
    end
    response
  else
    Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("nodes")
  end
end

.list_by_environment(environment, inflate = false) ⇒ Object 



564
565
566
567
568
569
570
571
572
 
# File 'lib/chef/node.rb', line 564

def self.list_by_environment(environment, inflate = false)
  if inflate
    response = Hash.new
    Chef::Search::Query.new.search(:node, "chef_environment:#{environment}") { |n| response[n.name] = n unless n.nil? }
    response
  else
    Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("environments/#{environment}/nodes")
  end
end

.load(name) ⇒ Object

Load a node by name



603
604
605
 
# File 'lib/chef/node.rb', line 603

def self.load(name)
  from_hash(Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("nodes/#{name}"))
end

Instance Method Details

#<=>(other_node) ⇒ Object 



664
665
666
 
# File 'lib/chef/node.rb', line 664

def <=>(other_node)
  self.name <=> other_node.name
end

#==(other) ⇒ Object 



656
657
658
659
660
661
662
 
# File 'lib/chef/node.rb', line 656

def ==(other)
  if other.kind_of?(self.class)
    self.name == other.name
  else
    false
  end
end

#[](attrib) ⇒ Object

Return an attribute of this node. Returns nil if the attribute is not found.



191
192
193
 
# File 'lib/chef/node.rb', line 191

def [](attrib)
  attributes[attrib]
end

#apply_expansion_attributes(expansion) ⇒ Object

Apply the default and overrides attributes from the expansion passed in, which came from roles.



453
454
455
456
457
458
459
460
461
462
463
464
465
 
# File 'lib/chef/node.rb', line 453

def apply_expansion_attributes(expansion)
  loaded_environment = if chef_environment == "_default"
                         Chef::Environment.new.tap { |e| e.name("_default") }
                       else
                         Chef::Environment.load(chef_environment)
                       end

  attributes.env_default = loaded_environment.default_attributes
  attributes.env_override = loaded_environment.override_attributes

  attribute.role_default = expansion.default_attrs
  attributes.role_override = expansion.override_attrs
end

#attribute?(attrib) ⇒ Boolean

Return true if this Node has a given attribute, false if not. Takes either a symbol or a string.

Only works on the top level. Preferred way is to use the normal [] style lookup and call attribute?()

Returns:

  • (Boolean) 


278
279
280
 
# File 'lib/chef/node.rb', line 278

def attribute?(attrib)
  attributes.attribute?(attrib)
end

#attributes ⇒ Object Also known as: attribute, construct_attributes 



183
184
185
 
# File 'lib/chef/node.rb', line 183

def attributes
  @attributes
end

#automatic_attrs ⇒ Object 



263
264
265
266
267
 
# File 'lib/chef/node.rb', line 263

def automatic_attrs
  attributes.top_level_breadcrumb = nil
  attributes.set_unless_value_present = false
  attributes.automatic
end

#automatic_attrs=(new_values) ⇒ Object 



269
270
271
 
# File 'lib/chef/node.rb', line 269

def automatic_attrs=(new_values)
  attributes.automatic = new_values
end

#chef_environment(arg = nil) ⇒ Object Also known as: environment 



125
126
127
128
129
130
131
 
# File 'lib/chef/node.rb', line 125

def chef_environment(arg = nil)
  set_or_return(
    :chef_environment,
    arg,
    { :regex => /^[\-[:alnum:]_]+$/, :kind_of => String }
  )
end

#chef_environment=(environment) ⇒ Object 



133
134
135
 
# File 'lib/chef/node.rb', line 133

def chef_environment=(environment)
  chef_environment(environment)
end

#consume_attributes(attrs) ⇒ Object

Consumes the combined run_list and other attributes in attrs



364
365
366
367
368
369
370
 
# File 'lib/chef/node.rb', line 364

def consume_attributes(attrs)
  normal_attrs_to_merge = consume_run_list(attrs)
  normal_attrs_to_merge = consume_chef_environment(normal_attrs_to_merge)
  Chef::Log.debug("Applying attributes from json file")
  self.normal_attrs = Chef::Mixin::DeepMerge.merge(normal_attrs, normal_attrs_to_merge)
  self.tags # make sure they're defined
end

#consume_chef_environment(attrs) ⇒ Object

chef_environment when set in -j JSON will take precedence over -E ENVIRONMENT. Ideally, IMO, the order of precedence should be (lowest to

highest):
 config_file
 -j JSON
 -E ENVIRONMENT

so that users could reuse their JSON and override the chef_environment configured within it with -E ENVIRONMENT. Because command line options are merged with Chef::Config there is currently no way to distinguish between an environment set via config from an environment set via command line.



409
410
411
412
413
414
415
 
# File 'lib/chef/node.rb', line 409

def consume_chef_environment(attrs)
  attrs = attrs ? attrs.dup : {}
  if env = attrs.delete("chef_environment")
    chef_environment(env)
  end
  attrs
end

#consume_external_attrs(ohai_data, json_cli_attrs) ⇒ Object

Consume data from ohai and Attributes provided as JSON on the command line.



351
352
353
354
355
356
357
358
359
360
361
 
# File 'lib/chef/node.rb', line 351

def consume_external_attrs(ohai_data, json_cli_attrs)
  Chef::Log.debug("Extracting run list from JSON attributes provided on command line")
  consume_attributes(json_cli_attrs)

  self.automatic_attrs = ohai_data

  platform, version = Chef::Platform.find_platform_and_version(self)
  Chef::Log.debug("Platform is #{platform} version #{version}")
  self.automatic[:platform] = platform
  self.automatic[:platform_version] = version
end

#consume_run_list(attrs) ⇒ Object

Extracts the run list from attrs and applies it. Returns the remaining attributes



387
388
389
390
391
392
393
394
395
396
397
 
# File 'lib/chef/node.rb', line 387

def consume_run_list(attrs)
  attrs = attrs ? attrs.dup : {}
  if new_run_list = attrs.delete("recipes") || attrs.delete("run_list")
    if attrs.key?("recipes") || attrs.key?("run_list")
      raise Chef::Exceptions::AmbiguousRunlistSpecification, "please set the node's run list using the 'run_list' attribute only."
    end
    Chef::Log.info("Setting the run_list to #{new_run_list} from CLI options")
    run_list(new_run_list)
  end
  attrs
end

#create ⇒ Object

Create the node via the REST API



638
639
640
641
642
643
644
645
646
647
648
649
650
 
# File 'lib/chef/node.rb', line 638

def create
  chef_server_rest.post("nodes", data_for_save)
  self
rescue Net::HTTPServerException => e
  # Chef Server before 12.3 rejects node JSON with 'policy_name' or
  # 'policy_group' keys, but 'policy_name' will be detected first.
  # Backcompat can be removed in 13.0
  if e.response.code == "400" && e.response.body.include?("Invalid key policy_name")
    chef_server_rest.post("nodes", data_for_save_without_policyfile_attrs)
  else
    raise
  end
end

#default ⇒ Object Also known as: default_attrs

Set a default of this node, but auto-vivify any Mashes that might be missing



217
218
219
220
221
 
# File 'lib/chef/node.rb', line 217

def default
  attributes.top_level_breadcrumb = nil
  attributes.set_unless_value_present = false
  attributes.default
end

#default_attrs=(new_values) ⇒ Object 



255
256
257
 
# File 'lib/chef/node.rb', line 255

def default_attrs=(new_values)
  attributes.default = new_values
end

#default_unless ⇒ Object

Set a default attribute of this node, auto-vivifying any mashes that are missing, but if the final value already exists, don’t set it



225
226
227
228
229
 
# File 'lib/chef/node.rb', line 225

def default_unless
  attributes.top_level_breadcrumb = nil
  attributes.set_unless_value_present = true
  attributes.default
end

#destroy ⇒ Object

Remove this node via the REST API



608
609
610
 
# File 'lib/chef/node.rb', line 608

def destroy
  chef_server_rest.delete("nodes/#{name}")
end

#display_hash ⇒ Object 



482
483
484
485
486
487
488
489
490
491
492
 
# File 'lib/chef/node.rb', line 482

def display_hash
  display = {}
  display["name"]             = name
  display["chef_environment"] = chef_environment
  display["automatic"]        = automatic_attrs
  display["normal"]           = normal_attrs
  display["default"]          = attributes.combined_default
  display["override"]         = attributes.combined_override
  display["run_list"]         = run_list.run_list_items
  display
end

#each(&block) ⇒ Object

Yield each key of the top level to the block.



283
284
285
 
# File 'lib/chef/node.rb', line 283

def each(&block)
  attributes.each(&block)
end

#each_attribute(&block) ⇒ Object

Iterates over each attribute, passing the attribute and value to the block.



288
289
290
 
# File 'lib/chef/node.rb', line 288

def each_attribute(&block)
  attributes.each_attribute(&block)
end

#expand!(data_source = "server") ⇒ Object

Expands the node’s run list and sets the default and override attributes. Also applies stored attributes (from json provided on the command line)

Returns the fully-expanded list of recipes, a RunListExpansion.

– TODO: timh/cw, 5-14-2010: Should this method exist? Should we instead modify default_attrs and override_attrs whenever our run_list is mutated? Or perhaps do something smarter like on-demand generation of default_attrs and override_attrs, invalidated only when run_list is mutated?

Raises:



436
437
438
439
440
441
442
443
444
445
446
447
448
449
 
# File 'lib/chef/node.rb', line 436

def expand!(data_source = "server")
  expansion = run_list.expand(chef_environment, data_source)
  raise Chef::Exceptions::MissingRole, expansion if expansion.errors?

  self.tags # make sure they're defined

  automatic_attrs[:recipes] = expansion.recipes.with_duplicate_names
  automatic_attrs[:expanded_run_list] = expansion.recipes.with_fully_qualified_names_and_version_constraints
  automatic_attrs[:roles] = expansion.roles

  apply_expansion_attributes(expansion)

  expansion
end

#for_json ⇒ Object 



499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
 
# File 'lib/chef/node.rb', line 499

def for_json
  result = {
    "name" => name,
    "chef_environment" => chef_environment,
    "json_class" => self.class.name,
    "automatic" => attributes.automatic,
    "normal" => attributes.normal,
    "chef_type" => "node",
    "default" => attributes.combined_default,
    "override" => attributes.combined_override,
    #Render correctly for run_list items so malformed json does not result
    "run_list" => @primary_runlist.run_list.map { |item| item.to_s },
  }
  # Chef Server rejects node JSON with extra keys; prior to 12.3,
  # "policy_name" and "policy_group" are unknown; after 12.3 they are
  # optional, therefore only including them in the JSON if present
  # maximizes compatibility for most people.
  unless policy_group.nil? && policy_name.nil?
    result["policy_name"] = policy_name
    result["policy_group"] = policy_group
  end
  result
end

#loaded_recipe(cookbook, recipe) ⇒ Object

used by include_recipe to add recipes to the expanded run_list to be saved back to the node and be searchable



310
311
312
313
314
 
# File 'lib/chef/node.rb', line 310

def loaded_recipe(cookbook, recipe)
  fully_qualified_recipe = "#{cookbook}::#{recipe}"

  automatic_attrs[:recipes] << fully_qualified_recipe unless Array(self[:recipes]).include?(fully_qualified_recipe)
end

#name(arg = nil) ⇒ Object

Set the name of this Node, or return the current name.



111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/chef/node.rb', line 111

def name(arg = nil)
  if arg != nil
    validate(
             { :name => arg },
             { :name => { :kind_of => String,
                          :cannot_be => :blank,
                          :regex => /^[\-[:alnum:]_:.]+$/ },
             })
    @name = arg
  else
    @name
  end
end

#node ⇒ Object

Used by DSL



94
95
96
 
# File 'lib/chef/node.rb', line 94

def node
  self
end

#normal ⇒ Object Also known as: set, normal_attrs

Set a normal attribute of this node, but auto-vivify any Mashes that might be missing



197
198
199
200
201
 
# File 'lib/chef/node.rb', line 197

def normal
  attributes.top_level_breadcrumb = nil
  attributes.set_unless_value_present = false
  attributes.normal
end

#normal_attrs=(new_values) ⇒ Object 



259
260
261
 
# File 'lib/chef/node.rb', line 259

def normal_attrs=(new_values)
  attributes.normal = new_values
end

#normal_unless ⇒ Object Also known as: set_unless

Set a normal attribute of this node, auto-vivifying any mashes that are missing, but if the final value already exists, don’t set it



207
208
209
210
211
 
# File 'lib/chef/node.rb', line 207

def normal_unless
  attributes.top_level_breadcrumb = nil
  attributes.set_unless_value_present = true
  attributes.normal
end

#override ⇒ Object Also known as: override_attrs

Set an override attribute of this node, but auto-vivify any Mashes that might be missing



233
234
235
236
237
 
# File 'lib/chef/node.rb', line 233

def override
  attributes.top_level_breadcrumb = nil
  attributes.set_unless_value_present = false
  attributes.override
end

#override_attrs=(new_values) ⇒ Object 



251
252
253
 
# File 'lib/chef/node.rb', line 251

def override_attrs=(new_values)
  attributes.override = new_values
end

#override_unless ⇒ Object

Set an override attribute of this node, auto-vivifying any mashes that are missing, but if the final value already exists, don’t set it



241
242
243
244
245
 
# File 'lib/chef/node.rb', line 241

def override_unless
  attributes.top_level_breadcrumb = nil
  attributes.set_unless_value_present = true
  attributes.override
end

#policy_group(arg = NULL_ARG) ⇒ String

The ‘policy_group` for this node. Setting this to a non-nil value will enable policyfile mode when `chef-client` is run. If set in the config file or in node json, running `chef-client` will update this value.

Parameters:

  • arg (String) (defaults to: NULL_ARG) —

    the new policy_group value

Returns:

  • (String) —

    the current policy_group, or the one you just set

See Also:



170
171
172
173
174
 
# File 'lib/chef/node.rb', line 170

def policy_group(arg = NULL_ARG)
  return @policy_group if arg.equal?(NULL_ARG)
  validate({ policy_group: arg }, { policy_group: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
  @policy_group = arg
end

#policy_group=(policy_group) ⇒ Object

A “non-DSL-style” setter for ‘policy_group`

See Also:



179
180
181
 
# File 'lib/chef/node.rb', line 179

def policy_group=(policy_group)
  policy_group(policy_group)
end

#policy_name(arg = NULL_ARG) ⇒ String

The ‘policy_name` for this node. Setting this to a non-nil value will enable policyfile mode when `chef-client` is run. If set in the config file or in node json, running `chef-client` will update this value.

Parameters:

  • arg (String) (defaults to: NULL_ARG) —

    the new policy_name value

Returns:

  • (String) —

    the current policy_name, or the one you just set

See Also:



148
149
150
151
152
 
# File 'lib/chef/node.rb', line 148

def policy_name(arg = NULL_ARG)
  return @policy_name if arg.equal?(NULL_ARG)
  validate({ policy_name: arg }, { policy_name: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
  @policy_name = arg
end

#policy_name=(policy_name) ⇒ Object

A “non-DSL-style” setter for ‘policy_name`

See Also:



157
158
159
 
# File 'lib/chef/node.rb', line 157

def policy_name=(policy_name)
  policy_name(policy_name)
end

#primary_runlist ⇒ Object 



321
322
323
 
# File 'lib/chef/node.rb', line 321

def primary_runlist
  @primary_runlist
end

#recipe?(recipe_name) ⇒ Boolean

Returns true if this Node expects a given recipe, false if not.

First, the run list is consulted to see whether the recipe is explicitly included. If it’s not there, it looks in ‘node`, which is populated when the run_list is expanded

NOTE: It’s used by cookbook authors

Returns:

  • (Boolean) 


304
305
306
 
# File 'lib/chef/node.rb', line 304

def recipe?(recipe_name)
  run_list.include?(recipe_name) || Array(self[:recipes]).include?(recipe_name)
end

#reset_defaults_and_overrides ⇒ Object

Clear defaults and overrides, so that any deleted attributes between runs are still gone.



419
420
421
422
 
# File 'lib/chef/node.rb', line 419

def reset_defaults_and_overrides
  self.default.clear
  self.override.clear
end

#role?(role_name) ⇒ Boolean

Returns true if this Node expects a given role, false if not.

Returns:

  • (Boolean) 


317
318
319
 
# File 'lib/chef/node.rb', line 317

def role?(role_name)
  run_list.include?("role[#{role_name}]")
end

#run_list(*args) ⇒ Object

Returns an Array of roles and recipes, in the order they will be applied. If you call it with arguments, they will become the new list of roles and recipes.



335
336
337
338
 
# File 'lib/chef/node.rb', line 335

def run_list(*args)
  rl = select_run_list
  args.length > 0 ? rl.reset!(args) : rl
end

#run_list=(list) ⇒ Object 



340
341
342
343
 
# File 'lib/chef/node.rb', line 340

def run_list=(list)
  rl = select_run_list
  rl = list
end

#run_list?(item) ⇒ Boolean

Returns true if this Node expects a given role, false if not.

Returns:

  • (Boolean) 


346
347
348
 
# File 'lib/chef/node.rb', line 346

def run_list?(item)
  run_list.detect { |r| r == item } ? true : false
end

#save ⇒ Object

Save this node via the REST API



613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
 
# File 'lib/chef/node.rb', line 613

def save
  # Try PUT. If the node doesn't yet exist, PUT will return 404,
  # so then POST to create.
  begin
    if Chef::Config[:why_run]
      Chef::Log.warn("In why-run mode, so NOT performing node save.")
    else
      chef_server_rest.put("nodes/#{name}", data_for_save)
    end
  rescue Net::HTTPServerException => e
    if e.response.code == "404"
      chef_server_rest.post("nodes", data_for_save)
    # Chef Server before 12.3 rejects node JSON with 'policy_name' or
    # 'policy_group' keys, but 'policy_name' will be detected first.
    # Backcompat can be removed in 13.0
    elsif e.response.code == "400" && e.response.body.include?("Invalid key policy_name")
      save_without_policyfile_attrs
    else
      raise
    end
  end
  self
end

#select_run_list ⇒ Object 



329
330
331
 
# File 'lib/chef/node.rb', line 329

def select_run_list
  @override_runlist.empty? ? @primary_runlist : @override_runlist
end

#set_cookbook_attribute ⇒ Object

after the run_context has been set on the node, go through the cookbook_collection and setup the node attribute so that it is published in the node object



86
87
88
89
90
91
 
# File 'lib/chef/node.rb', line 86

def set_cookbook_attribute
  return unless run_context.cookbook_collection
  run_context.cookbook_collection.each do |cookbook_name, cookbook|
    automatic_attrs[:cookbooks][cookbook_name][:version] = cookbook.version
  end
end

#tag(*args) ⇒ Object 



378
379
380
381
382
383
384
 
# File 'lib/chef/node.rb', line 378

def tag(*args)
  args.each do |tag|
    tags.push(tag.to_s) unless tags.include? tag.to_s
  end

  tags
end

#tags ⇒ Object

Lazy initializer for tags attribute



373
374
375
376
 
# File 'lib/chef/node.rb', line 373

def tags
  normal[:tags] = Array(normal[:tags])
  normal[:tags]
end

#to_hash ⇒ Object

Transform the node to a Hash



468
469
470
471
472
473
474
475
476
477
478
479
480
 
# File 'lib/chef/node.rb', line 468

def to_hash
  index_hash = Hash.new
  index_hash["chef_type"] = "node"
  index_hash["name"] = name
  index_hash["chef_environment"] = chef_environment
  attribute.each do |key, value|
    index_hash[key] = value
  end
  index_hash["recipe"] = run_list.recipe_names if run_list.recipe_names.length > 0
  index_hash["role"] = run_list.role_names if run_list.role_names.length > 0
  index_hash["run_list"] = run_list.run_list_items
  index_hash
end

#to_json(*a) ⇒ Object

Serialize this object as a hash



495
496
497
 
# File 'lib/chef/node.rb', line 495

def to_json(*a)
  Chef::JSONCompat.to_json(for_json, *a)
end

#to_s ⇒ Object 



652
653
654
 
# File 'lib/chef/node.rb', line 652

def to_s
  "node[#{name}]"
end

#update_from!(o) ⇒ Object 



523
524
525
526
527
528
529
530
531
 
# File 'lib/chef/node.rb', line 523

def update_from!(o)
  run_list.reset!(o.run_list)
  self.automatic_attrs = o.automatic_attrs
  self.normal_attrs = o.normal_attrs
  self.override_attrs = o.override_attrs
  self.default_attrs = o.default_attrs
  chef_environment(o.chef_environment)
  self
end