class Redoxed::Nodes

Attributes

jobs[RW]
source[RW]

Public Class Methods

new(opts = {}) click to toggle source
Calls superclass method
# File lib/redoxed/nodes.rb, line 118
def initialize(opts = {})
  super()
  node = opts.delete :node
  @mutex = Mutex.new # we compete for the nodes with webapi thread
  if (nodes = opts.delete(:nodes))
    replace nodes
  else
    load node
  end
end

Public Instance Methods

fetch(node_name, group) click to toggle source
# File lib/redoxed/nodes.rb, line 61
def fetch(node_name, group)
  yield_node_output(node_name) do |node, output|
    output.fetch node, group
  end
end
find_node_index(node) click to toggle source

@param node node whose index number in Nodes to find @return [Fixnum] index number of node in Nodes

# File lib/redoxed/nodes.rb, line 94
def find_node_index(node)
  find_index(node) || raise(Redoxed::NodeNotFound, "unable to find '#{node}'")
end
get() click to toggle source

@return [String] node from the head of the array

# File lib/redoxed/nodes.rb, line 86
def get
  with_lock do
    (self << shift).last
  end
end
get_diff(node_name, group, oid1, oid2) click to toggle source
# File lib/redoxed/nodes.rb, line 110
def get_diff(node_name, group, oid1, oid2)
  yield_node_output(node_name) do |node, output|
    output.get_diff node, group, oid1, oid2
  end
end
get_version(node_name, group, oid) click to toggle source
# File lib/redoxed/nodes.rb, line 104
def get_version(node_name, group, oid)
  yield_node_output(node_name) do |node, output|
    output.get_version node, group, oid
  end
end
list() click to toggle source
# File lib/redoxed/nodes.rb, line 48
def list
  with_lock do
    map { |e| e.serialize }
  end
end
load(node_want = nil) click to toggle source
# File lib/redoxed/nodes.rb, line 9
def load(node_want = nil)
  with_lock do
    new = []
    @source = Redoxed.config.source.default
    Redoxed.mgr.add_source(@source) || raise(MethodNotFound, "cannot load node source '#{@source}', not found")
    Redoxed.logger.info "lib/redoxed/nodes.rb: Loading nodes"
    nodes = Redoxed.mgr.source[@source].new.load node_want
    nodes.each do |node|
      # we want to load specific node(s), not all of them
      next unless node_want? node_want, node

      begin
        node_obj = Node.new node
        new.push node_obj
      rescue ModelNotFound => err
        Redoxed.logger.error "node %s raised %s with message '%s'" % [node, err.class, err.message]
      rescue Resolv::ResolvError => err
        Redoxed.logger.error "node %s is not resolvable, raised %s with message '%s'" % [node, err.class, err.message]
      end
    end
    size.zero? ? replace(new) : update_nodes(new)
    Redoxed.logger.info "lib/redoxed/nodes.rb: Loaded #{size} nodes"
  end
end
next(node, opt = {}) click to toggle source

@param node [String] name of the node moved into the head of array

# File lib/redoxed/nodes.rb, line 68
def next(node, opt = {})
  return unless waiting.find_node_index(node)

  with_lock do
    n = del node
    n.user = opt['user']
    n.email = opt['email']
    n.msg  = opt['msg']
    n.from = opt['from']
    # set last job to nil so that the node is picked for immediate update
    n.last = nil
    put n
    jobs.want += 1 if Redoxed.config.next_adds_job?
  end
end
Also aliased as: top
node_want?(node_want, node) click to toggle source
# File lib/redoxed/nodes.rb, line 34
def node_want?(node_want, node)
  return true unless node_want

  node_want_ip = (IPAddr.new(node_want) rescue false)
  name_is_ip   = (IPAddr.new(node[:name]) rescue false)
  if name_is_ip && (node_want_ip == node[:name])
    true
  elsif node[:ip] && (node_want_ip == node[:ip])
    true
  elsif node_want.match node[:name]
    true unless name_is_ip
  end
end
show(node) click to toggle source
# File lib/redoxed/nodes.rb, line 54
def show(node)
  with_lock do
    i = find_node_index node
    self[i].serialize
  end
end
top(node, opt = {})
Alias for: next
version(node_name, group) click to toggle source
# File lib/redoxed/nodes.rb, line 98
def version(node_name, group)
  yield_node_output(node_name) do |node, output|
    output.version node, group
  end
end

Private Instance Methods

del(node) click to toggle source

@param node node which is removed from nodes list @return [Node] deleted node

# File lib/redoxed/nodes.rb, line 139
def del(node)
  delete_at find_node_index(node)
end
find_index(node) click to toggle source
# File lib/redoxed/nodes.rb, line 133
def find_index(node)
  index { |e| [e.name, e.ip].include? node }
end
running() click to toggle source

@return [Nodes] list of nodes running now

# File lib/redoxed/nodes.rb, line 144
def running
  Nodes.new nodes: select { |node| node.running? }
end
update_nodes(nodes) click to toggle source

walks list of new nodes, if old node contains same name, adds last and stats information from old to new.

@todo can we trust name to be unique identifier, what about when groups are used? @param [Array] nodes Array of nodes used to replace+update old

# File lib/redoxed/nodes.rb, line 158
def update_nodes(nodes)
  old = dup
  replace(nodes)
  each do |node|
    begin
      if (i = old.find_node_index(node.name))
        node.stats = old[i].stats
        node.last  = old[i].last
      end
    rescue Redoxed::NodeNotFound
    end
  end
  sort_by! { |x| x.last.nil? ? Time.new(0) : x.last.end }
end
waiting() click to toggle source

@return [Nodes] list of nodes waiting (not running)

# File lib/redoxed/nodes.rb, line 149
def waiting
  Nodes.new nodes: select { |node| not node.running? }
end
with_lock(&block) click to toggle source
# File lib/redoxed/nodes.rb, line 129
def with_lock(&block)
  @mutex.synchronize(&block)
end
yield_node_output(node_name) { |node, output| ... } click to toggle source
# File lib/redoxed/nodes.rb, line 173
def yield_node_output(node_name)
  with_lock do
    node = find { |n| n.name == node_name }
    output = node.output.new
    raise Redoxed::NotSupported unless output.respond_to? :fetch

    yield node, output
  end
end