MCollective::Discovery

   # File lib/mcollective/discovery.rb, line 3
3:     def initialize(client)
4:       @known_methods = find_known_methods
5:       @default_method = Config.instance.default_discovery_method
6:       @client = client
7:     end

    # File lib/mcollective/discovery.rb, line 62
62:     def check_capabilities(filter)
63:       capabilities = ddl.discovery_interface[:capabilities]
64: 
65:       unless capabilities.include?(:classes)
66:         raise "Cannot use class filters while using the '%s' discovery method" % discovery_method unless filter["cf_class"].empty?
67:       end
68: 
69:       unless capabilities.include?(:facts)
70:         raise "Cannot use fact filters while using the '%s' discovery method" % discovery_method unless filter["fact"].empty?
71:       end
72: 
73:       unless capabilities.include?(:identity)
74:         raise "Cannot use identity filters while using the '%s' discovery method" % discovery_method unless filter["identity"].empty?
75:       end
76: 
77:       unless capabilities.include?(:compound)
78:         raise "Cannot use compound filters while using the '%s' discovery method" % discovery_method unless filter["compound"].empty?
79:       end
80:     end

    # File lib/mcollective/discovery.rb, line 47
47:     def ddl
48:       @ddl ||= DDL.new(discovery_method, :discovery)
49: 
50:       # if the discovery method got changed we might have an old DDL cached
51:       # this will detect that and reread the correct DDL from disk
52:       unless @ddl.meta[:name] == discovery_method
53:         @ddl = DDL.new(discovery_method, :discovery)
54:       end
55: 
56:       return @ddl
57:     end

     # File lib/mcollective/discovery.rb, line 127
127:     def discover(filter, timeout, limit)
128:       raise "Limit has to be an integer" unless limit.is_a?(Fixnum)
129: 
130:       force_discovery_method_by_filter(filter)
131: 
132:       check_capabilities(filter)
133: 
134:       discovered = discovery_class.discover(filter, discovery_timeout(timeout, filter), limit, @client)
135: 
136:       if limit > 0
137:         return discovered[0,limit]
138:       else
139:         return discovered
140:       end
141:     end

    # File lib/mcollective/discovery.rb, line 39
39:     def discovery_class
40:       method = discovery_method.capitalize
41: 
42:       PluginManager.loadclass("MCollective::Discovery::#{method}") unless self.class.const_defined?(method)
43: 
44:       self.class.const_get(method)
45:     end

    # File lib/mcollective/discovery.rb, line 21
21:     def discovery_method
22:       method = "mc"
23: 
24:       if @client.options[:discovery_method]
25:         method = @client.options[:discovery_method]
26:       else
27:         method = @default_method
28:       end
29: 
30:       raise "Unknown discovery method %s" % method unless has_method?(method)
31: 
32:       unless method == "mc"
33:         raise "Custom discovery methods require direct addressing mode" unless Config.instance.direct_addressing
34:       end
35: 
36:       return method
37:     end

     # File lib/mcollective/discovery.rb, line 117
117:     def discovery_timeout(timeout, filter)
118:       timeout = ddl.meta[:timeout] unless timeout
119: 
120:       unless (filter["compound"] && filter["compound"].empty?)
121:         timeout + timeout_for_compound_filter(filter["compound"])
122:       else
123:         timeout
124:       end
125:     end

    # File lib/mcollective/discovery.rb, line 9
 9:     def find_known_methods
10:       PluginManager.find("discovery")
11:     end

    # File lib/mcollective/discovery.rb, line 17
17:     def force_direct_mode?
18:       discovery_method != "mc"
19:     end

    # File lib/mcollective/discovery.rb, line 83
83:     def force_discovery_method_by_filter(filter)
84:       unless discovery_method == "mc"
85:         unless filter["compound"].empty?
86:           Log.info "Switching to mc discovery method because compound filters are used"
87:           @client.options[:discovery_method] = "mc"
88: 
89:           return true
90:         end
91:       end
92: 
93:       return false
94:     end

    # File lib/mcollective/discovery.rb, line 13
13:     def has_method?(method)
14:       @known_methods.include?(method)
15:     end

     # File lib/mcollective/discovery.rb, line 99
 99:     def timeout_for_compound_filter(compound_filter)
100:       return 0 if compound_filter.nil? || compound_filter.empty?
101: 
102:       timeout = 0
103: 
104:       compound_filter.each do |filter|
105:         filter.each do |statement|
106:           if statement["fstatement"]
107:             pluginname = Data.pluginname(statement["fstatement"]["name"])
108:             ddl = DDL.new(pluginname, :data)
109:             timeout += ddl.meta[:timeout]
110:           end
111:         end
112:       end
113: 
114:       timeout
115:     end