Node

# File lib/arborist/node.rb, line 87
        

# File lib/arborist/node.rb, line 91
        

# File lib/arborist/node.rb, line 83
        

# File lib/arborist/node.rb, line 95
        

# File lib/arborist/node.rb, line 420
def modify( attributes )
        attributes = stringify_keys( attributes )

        self.parent( attributes['parent'] )
        self.description( attributes['description'] )
        self.config( attributes['config'] )

        if attributes['tags']
                @tags.clear
                self.tags( attributes['tags'] )
        end
end

# File lib/arborist/node.rb, line 411
def source=( source )
        @source = URI( source )
end

# File lib/arborist/node.rb, line 100
        

# File lib/arborist/node.rb, line 107
        

# File lib/arborist/node.rb, line 114
state_machine( :status, initial: :unknown ) do

        state :unknown,
                :up,
                :down,
                :warn,
                :acked,
                :disabled,
                :quieted

        event :update do
                transition [:down, :warn, :unknown, :acked] => :up, unless: :has_errors_or_warnings?
                transition [:up, :warn, :unknown] => :down, if: :has_errors?
                transition [:up, :down, :unknown] => :warn, if: :has_only_warnings?
        end

        event :acknowledge do
                transition any - [:down] => :disabled
                transition :down => :acked
        end

        event :unacknowledge do
                transition [:acked, :disabled] => :warn, if: :has_warnings?
                transition [:acked, :disabled] => :down, if: :has_errors?
                transition [:acked, :disabled] => :unknown
        end

        event :handle_event do
                transition any - [:disabled, :quieted, :acked] => :quieted, if: :has_quieted_reason?
                transition :quieted => :unknown, unless: :has_quieted_reason?
        end

        event :reparent do
                transition any - [:disabled, :quieted, :acked] => :unknown
                transition :quieted => :unknown, unless: :has_quieted_reason?
        end

        before_transition [:acked, :disabled] => any, do: :save_previous_ack

        after_transition any => :acked, do: :on_ack
        after_transition :acked => :up, do: :on_ack_cleared
        after_transition :down => :up, do: :on_node_up
        after_transition :up => :warn, do: :on_node_warn
        after_transition [:unknown, :warn, :up] => :down, do: :on_node_down
        after_transition [:acked, :unknown, :warn, :up] => :disabled, do: :on_node_disabled
        after_transition any => :quieted, do: :on_node_quieted
        after_transition :disabled => :unknown, do: :on_node_enabled
        after_transition :quieted => :unknown, do: :on_node_unquieted

        after_transition any => any, do: :log_transition
        after_transition any => any, do: :make_transition_event
        after_transition any => any, do: :update_status_changed

        after_transition do: :add_status_to_update_delta
end

# File lib/arborist/node.rb, line 75
        

# File lib/arborist/node.rb, line 79
        

# File lib/arborist/node.rb, line 475
def all_of( *identifiers, on: nil )
        return Arborist::Dependency.on( :all, *identifiers, prefixes: on )
end

# File lib/arborist/node.rb, line 469
def any_of( *identifiers, on: nil )
        return Arborist::Dependency.on( :any, *identifiers, prefixes: on )
end

# File lib/arborist/node.rb, line 497
def config( new_config=nil )
        @config.merge!( stringify_keys( new_config ) ) if new_config
        return @config
end

# File lib/arborist/node.rb, line 481
def depends_on( *dependencies, on: nil )
        dependencies = self.all_of( *dependencies, on: on )

        self.log.debug "Setting secondary dependencies to: %p" % [ dependencies ]
        self.dependencies = check_dependencies( dependencies )
end

# File lib/arborist/node.rb, line 454
def description( new_description=nil )
        return @description unless new_description
        @description = new_description.to_s
end

# File lib/arborist/node.rb, line 490
def has_dependencies?
        return !self.dependencies.empty?
end

# File lib/arborist/node.rb, line 442
def parent( new_parent=nil )
        return @parent if new_parent.nil?

        @parent = if new_parent.respond_to?( :identifier )
                        new_parent.identifier.to_s
                else
                        @parent = new_parent.to_s
                end
end

# File lib/arborist/node.rb, line 461
def tags( *tags )
        tags.flatten!
        @tags.merge( tags.map(&:to_s) ) unless tags.empty?
        return @tags.to_a
end

# File lib/arborist/node.rb, line 980
def <<( node )
        self.add_child( node )
        return self
end

# File lib/arborist/node.rb, line 971
def add_child( node )
        self.log.debug "Adding node %p as a child. Parent = %p" % [ node, node.parent ]
        raise "%p is not a child of %p" % [ node, self ] if
                node.parent && node.parent != self.identifier
        self.children[ node.identifier ] = node
end

# File lib/arborist/node.rb, line 937
def each( &block )
        return self.children.values.each( &block )
end

# File lib/arborist/node.rb, line 943
def has_children?
        return !self.children.empty?
end

# File lib/arborist/node.rb, line 949
def operational?
        return self.identifier.start_with?( '_' )
end

# File lib/arborist/node.rb, line 964
def reachable?
        return !self.unreachable?
end

# File lib/arborist/node.rb, line 987
def remove_child( node )
        self.log.debug "Removing node %p from children" % [ node ]
        return self.children.delete( node.identifier )
end

# File lib/arborist/node.rb, line 956
def unreachable?
        self.log.debug "Testing for reachability; status is: %p" % [ self.status ]
        return UNREACHABLE_STATES.include?( self.status )
end

# File lib/arborist/node.rb, line 604
def acknowledge( **args )
        super()

        self.ack = args

        events = self.pending_change_events.clone
        events << self.make_delta_event unless self.update_delta.empty?
        results = self.broadcast_events( *events )
        self.log.debug ">>> Results from broadcast: %p" % [ results ]
        events.concat( results )

        return events
ensure
        self.clear_transition_temp_vars
end

# File lib/arborist/node.rb, line 517
def add_subscription( subscription )
        self.subscriptions[ subscription.id ] = subscription
end

# File lib/arborist/node.rb, line 789
def broadcast_events( *events )
        events.flatten!
        results = self.children.flat_map do |identifier, child|
                self.log.debug "Broadcasting %d events to %p" % [ events.length, identifier ]
                events.flat_map do |event|
                        child.handle_event( event )
                end
        end

        return results
end

# File lib/arborist/node.rb, line 669
def clear_transition_temp_vars
        self.previous_ack = nil
        self.update_delta.clear
        self.pending_change_events.clear
end

# File lib/arborist/node.rb, line 846
def dependencies_down?
        return self.dependencies.down?
end

# File lib/arborist/node.rb, line 853
def dependencies_up?
        return !self.dependencies_down?
end

# File lib/arborist/node.rb, line 736
def fetch_values( value_spec=nil )
        state = self.properties.merge( self.operational_values )
        state = stringify_keys( state )
        state = make_serializable( state )

        if value_spec
                self.log.debug "Eliminating all values except: %p (from keys: %p)" %
                        [ value_spec, state.keys ]
                state.delete_if {|key, _| !value_spec.include?(key) }
        end

        return state
end

# File lib/arborist/node.rb, line 529
def find_matching_subscriptions( event )
        return self.subscriptions.values.find_all {|sub| event =~ sub }
end

# File lib/arborist/node.rb, line 804
def handle_event( event )
        self.log.debug "Handling %p" % [ event ]
        handler_name = "handle_%s_event" % [ event.type.gsub('.', '_') ]

        if self.respond_to?( handler_name )
                self.log.debug "Handling a %s event." % [ event.type ]
                self.method( handler_name ).call( event )
        else
                self.log.debug "No handler for a %s event!" % [ event.type ]
        end

        self.log.debug ">>> Pending change events before: %p" % [ self.pending_change_events ]

        super # to state-machine

        results = self.pending_change_events.clone
        self.log.debug ">>> Pending change events after: %p" % [ results ]
        results << self.make_delta_event unless self.update_delta.empty?

        child_results = self.broadcast_events( *results )
        results.concat( child_results )

        self.publish_events( *results )

        return results
ensure
        self.clear_transition_temp_vars
end

# File lib/arborist/node.rb, line 882
def handle_node_disabled_event( event )
        self.log.debug "Got a node.disabled event: %p" % [ event ]
        self.dependencies.mark_down( event.node.identifier )

        if self.dependencies_down?
                self.quieted_reasons[ :secondary ] = "Secondary dependencies not met: %s" %
                        [ self.dependencies.down_reason ]
        end

        if event.node.identifier == self.parent
                self.quieted_reasons[ :primary ] = "Parent disabled: %s" % [ self.parent ]
        end
end

# File lib/arborist/node.rb, line 866
def handle_node_down_event( event )
        self.log.debug "Got a node.down event: %p" % [ event ]
        self.dependencies.mark_down( event.node.identifier )

        if self.dependencies_down?
                self.quieted_reasons[ :secondary ] = "Secondary dependencies not met: %s" %
                        [ self.dependencies.down_reason ]
        end

        if event.node.identifier == self.parent
                self.quieted_reasons[ :primary ] = "Parent down: %s" % [ self.parent ] # :TODO: backtrace?
        end
end

# File lib/arborist/node.rb, line 898
def handle_node_quieted_event( event )
        self.log.debug "Got a node.quieted event: %p" % [ event ]
        self.dependencies.mark_down( event.node.identifier )

        if self.dependencies_down?
                self.quieted_reasons[ :secondary ] = "Secondary dependencies not met: %s" %
                        [ self.dependencies.down_reason ]
        end

        if event.node.identifier == self.parent
                self.quieted_reasons[ :primary ] = "Parent quieted: %s" % [ self.parent ] # :TODO: backtrace?
        end
end

# File lib/arborist/node.rb, line 914
def handle_node_up_event( event )
        self.log.debug "Got a node.%s event: %p" % [ event.type, event ]

        self.dependencies.mark_up( event.node.identifier )
        self.quieted_reasons.delete( :secondary ) if self.dependencies_up?

        if event.node.identifier == self.parent
                self.log.info "Parent of %s (%s) came back up." % [
                        self.identifier,
                        self.parent
                ]
                self.quieted_reasons.delete( :primary )
        end
end

# File lib/arborist/node.rb, line 860
def has_quieted_reason?
        return !self.quieted_reasons.empty?
end

# File lib/arborist/node.rb, line 683
def make_delta_event
        self.log.debug "Making node.delta event: %p" % [ self.update_delta ]
        return Arborist::Event.create( 'node_delta', self, self.update_delta )
end

# File lib/arborist/node.rb, line 677
def make_update_event
        return Arborist::Event.create( 'node_update', self )
end

# File lib/arborist/node.rb, line 714
def match_criteria?( key, val )
        array_val = Array( val )
        return case key
                when 'status'
                        array_val.include?( self.status )
                when 'type'
                        array_val.include?( self.type )
                when 'parent'
                        array_val.include?( self.parent )
                when 'tag' then @tags.include?( val.to_s )
                when 'tags' then array_val.all? {|tag| @tags.include?(tag) }
                when 'identifier'
                        array_val.include?( self.identifier )
                when 'config'
                        val.all? {|ikey, ival| hash_matches(@config, ikey, ival) }
                else
                        hash_matches( @properties, key, val )
                end
end

# File lib/arborist/node.rb, line 697
def matches?( criteria, if_empty: true )

        # Omit 'delta' criteria from matches; delta matching is done separately.
        criteria = criteria.dup
        criteria.delete( 'delta' )

        self.log.debug "Node matching %p (%p if empty)" % [ criteria, if_empty ]
        return if_empty if criteria.empty?

        self.log.debug "Matching %p against criteria: %p" % [ self, criteria ]
        return criteria.all? do |key, val|
                self.match_criteria?( key, val )
        end.tap {|match| self.log.debug "  node %s match." % [ match ? "DID" : "did not"] }
end

# File lib/arborist/node.rb, line 641
def merge_and_record_delta( key, oldval, newval, prefixes=[] )
        self.log.debug "Merging property %s: %p -> %p" % [
                (prefixes + [key]).join('.'),
                oldval,
                newval
        ]

        # Merge them (recursively) if they're both merge-able
        if oldval.respond_to?( :merge! ) && newval.respond_to?( :merge! )
                return oldval.merge( newval ) do |ikey, ioldval, inewval|
                        self.merge_and_record_delta( ikey, ioldval, inewval, prefixes + [key] )
                end

        # Otherwise just directly compare them and record any changes
        else
                unless oldval == newval
                        prefixed_delta = prefixes.inject( self.update_delta ) do |hash, key|
                                hash[ key ]
                        end
                        prefixed_delta[ key ] = [ oldval, newval ]
                end

                return newval
        end
end

# File lib/arborist/node.rb, line 535
def node_subscribers
        self.log.debug "Finding node subscribers among %d subscriptions" % [ self.subscriptions.length ]
        return self.subscriptions.each_with_object( Set.new ) do |(identifier, sub), set|
                if sub.respond_to?( :node_identifier )
                        set.add( sub.node_identifier )
                else
                        self.log.debug "Skipping %p: not a node subscription" % [ sub ]
                end
        end
end

# File lib/arborist/node.rb, line 753
def operational_values
        values = OPERATIONAL_ATTRIBUTES.each_with_object( {} ) do |key, hash|
                hash[ key ] = self.send( key )
        end

        return values
end

# File lib/arborist/node.rb, line 780
def publish_events( *events )
        self.log.debug "Got events to publish: %p" % [ events ]
        self.subscriptions.each_value do |sub|
                sub.on_events( *events )
        end
end

# File lib/arborist/node.rb, line 764
def register_secondary_dependencies( manager )
        self.dependencies.all_identifiers.each do |identifier|
                # Check to be sure the identifier isn't a descendant or ancestor
                if manager.ancestors_for( self ).any? {|node| node.identifier == identifier}
                        raise Arborist::ConfigError, "Can't depend on ancestor node %p." % [ identifier ]
                elsif manager.descendants_for( self ).any? {|node| node.identifier == identifier }
                        raise Arborist::ConfigError, "Can't depend on descendant node %p." % [ identifier ]
                end

                sub = Arborist::NodeSubscription.new( self )
                manager.subscribe( identifier, sub )
        end
end

# File lib/arborist/node.rb, line 523
def remove_subscription( subscription_id )
        return self.subscriptions.delete( subscription_id )
end

# File lib/arborist/node.rb, line 835
def reparent( old_parent, new_parent )
        old_parent.remove_child( self )
        self.parent( new_parent.identifier )
        new_parent.add_child( self )

        self.quieted_reasons.delete( :primary )
        super
end

# File lib/arborist/node.rb, line 691
def state_has_changed?
        return ! self.update_delta.empty?
end

# File lib/arborist/node.rb, line 510
def type
        return 'anonymous' unless self.class.name
        return self.class.name.sub( /.*::/, '' ).downcase
end

# File lib/arborist/node.rb, line 622
def unacknowledge
        super()

        self.ack = nil

        events = self.pending_change_events.clone
        events << self.make_delta_event unless self.update_delta.empty?
        results = self.broadcast_events( *events )
        self.log.debug ">>> Results from broadcast: %p" % [ results ]
        events.concat( results )

        return events
ensure
        self.clear_transition_temp_vars
end

# File lib/arborist/node.rb, line 548
def update( new_properties, monitor_key='_' )
        self.last_contacted = Time.now
        self.update_properties( new_properties, monitor_key )

        # Super to the state machine event method
        super

        events = self.pending_change_events.clone
        events << self.make_update_event
        events << self.make_delta_event unless self.update_delta.empty?

        results = self.broadcast_events( *events )
        self.log.debug ">>> Results from broadcast: %p" % [ results ]
        events.concat( results )

        return events
ensure
        self.clear_transition_temp_vars
end

# File lib/arborist/node.rb, line 584
def update_errors( monitor_key, value=nil )
        if value
                self.errors[ monitor_key ] = value
        else
                self.errors.delete( monitor_key )
        end
end

# File lib/arborist/node.rb, line 570
def update_properties( new_properties, monitor_key )
        monitor_key ||= '_'
        new_properties = stringify_keys( new_properties )

        self.log.debug "Updated via a %s monitor: %p" % [ monitor_key, new_properties ]
        self.update_errors( monitor_key, new_properties.delete('error') )
        self.update_warnings( monitor_key, new_properties.delete('warning') )

        self.properties.merge!( new_properties, &self.method(:merge_and_record_delta) )
        compact_hash( self.properties )
end

# File lib/arborist/node.rb, line 594
def update_warnings( monitor_key, value=nil )
        if value
                self.warnings[ monitor_key ] = value
        else
                self.warnings.delete( monitor_key )
        end
end

# File lib/arborist/node.rb, line 1153
def ==( other_node )
        return                          other_node.identifier == self.identifier &&
                other_node.parent == self.parent &&
                other_node.description == self.description &&
                other_node.tags == self.tags
end

# File lib/arborist/node.rb, line 1110
def marshal_dump
        return self.to_h.merge( dependencies: self.dependencies )
end

# File lib/arborist/node.rb, line 1117
def marshal_load( hash )
        self.log.debug "Restoring from serialized hash: %p" % [ hash ]
        @identifier      = hash[:identifier]
        @properties      = hash[:properties]

        @parent          = hash[:parent]
        @description     = hash[:description]
        @tags            = Set.new( hash[:tags] )
        @config          = hash[:config]
        @children        = {}

        @status          = hash[:status]
        @status_changed  = Time.parse( hash[:status_changed] )
        @status_last_changed = Time.parse( hash[:status_last_changed] )
        @ack             = Arborist::Node::Ack.from_hash( hash[:ack] ) if hash[:ack]

        @errors          = hash[:errors]
        @warnings        = hash[:warnings]
        @properties      = hash[:properties] || {}
        @last_contacted  = Time.parse( hash[:last_contacted] )
        @quieted_reasons = hash[:quieted_reasons] || {}
        self.log.debug "Deps are: %p" % [ hash[:dependencies] ]
        @dependencies    = hash[:dependencies]

        @update_delta    = Hash.new do |h,k|
                h[ k ] = Hash.new( &h.default_proc )
        end

        @pending_change_events = []
        @subscriptions         = {}

end

# File lib/arborist/node.rb, line 1055
def restore( old_node )
        @status          = old_node.status
        @properties      = old_node.properties.dup
        @ack             = old_node.ack.dup if old_node.ack
        @last_contacted  = old_node.last_contacted
        @status_changed  = old_node.status_changed
        @errors          = old_node.errors
        @warnings        = old_node.warnings
        @quieted_reasons = old_node.quieted_reasons
        @status_last_changed = old_node.status_last_changed

        # Only merge in downed dependencies.
        old_node.dependencies.each_downed do |identifier, time|
                @dependencies.mark_down( identifier, time )
        end
end

# File lib/arborist/node.rb, line 1076
def to_h( depth: 0 )
        hash = {
                identifier: self.identifier,
                type: self.class.name.to_s.sub( /.+::/, '' ).downcase,
                parent: self.parent,
                description: self.description,
                tags: self.tags,
                config: self.config,
                status: self.status,
                properties: self.properties.dup,
                ack: self.ack ? self.ack.to_h : nil,
                last_contacted: self.last_contacted ? self.last_contacted.iso8601 : nil,
                status_changed: self.status_changed ? self.status_changed.iso8601 : nil,
                status_last_changed: self.status_last_changed ? self.status_last_changed.iso8601 : nil,
                errors: self.errors,
                warnings: self.warnings,
                dependencies: self.dependencies.to_h,
                quieted_reasons: self.quieted_reasons,
        }

        if depth.nonzero?
                # self.log.debug "including children for depth %p" % [ depth ]
                hash[ :children ] = self.children.each_with_object( {} ) do |(ident, node), h|
                        h[ ident ] = node.to_h( depth: depth - 1 )
                end
        else
                hash[ :children ] = {}
        end

        return hash
end

# File lib/arborist/node.rb, line 999
def acked_description
        return self.ack.description if self.ack
        return "(unset)"
end

# File lib/arborist/node.rb, line 1033
def inspect
        return "#<%p:%#x [%s] -> %s %p %s %s, %d children, %s>" % [
                self.class,
                self.object_id * 2,
                self.identifier,
                self.parent || 'root',
                self.description || "(no description)",
                self.node_description.to_s,
                self.source,
                self.children.length,
                self.status_description,
        ]
end

# File lib/arborist/node.rb, line 1027
def node_description
        return nil
end

# File lib/arborist/node.rb, line 1006
def status_description
        case self.status
        when 'up', 'down', 'warn'
                return "%s as of %s" % [ self.status.upcase, self.last_contacted ]
        when 'acked'
                return "ACKed %s" % [ self.acked_description ]
        when 'disabled'
                return "disabled %s" % [ self.acked_description ]
        when 'quieted'
                reasons = self.quieted_reasons.values.join( ',' )
                return "quieted: %s" % [ reasons ]
        when 'unknown'
                return "in an 'unknown' state"
        else
                return "in an unhandled state"
        end
end