zcollective 0.0.9

data/bin/zcollective

@@ -0,0 +1,659 @@
+#!/usr/bin/env ruby
+
+# Copyright (c) 2012, 2013, The Scale Factory Ltd.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#   * Neither the name of the The Scale Factory Ltd nor the
+#     names of its contributors may be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE SCALE FACTORY LTD BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'rubygems'
+require 'optparse'
+require 'logger'
+require 'json'
+require 'netaddr'
+require 'zcollective/zabbixclient'
+
+begin 
+    require 'mcollective'
+rescue LoadError => e
+    raise unless e.message =~ /mcollective/
+    STDERR.puts "ZCollective requires that you install mcollective. " <<
+        "This is not supplied as a gem - install the OS packages from puppetlabs"
+    exit 2
+end
+
+options = {}
+optparse = OptionParser.new do |opts|
+
+    options[:zabbix_api_url] = 'http://localhost/zabbix/api_jsonrpc.php'
+    opts.on('-z', '--zabbix-api-url url', 'JSON-RPC endpoint for zabbix server') do |u|
+        options[:zabbix_api_url] = u
+    end
+
+    options[:zabbix_user] = 'Admin'
+    opts.on('-u', '--zabbix-user user', 'Zabbix API username') do |u|
+        options[:zabbix_user] = u
+    end
+
+    options[:zabbix_pass] = 'zabbix'
+    opts.on('-p', '--zabbix-pass pass', 'Zabbix API password') do |p|
+        options[:zabbix_pass] = p
+    end
+
+    options[:debug] = false
+    opts.on('-d', '--debug', 'Enable debugging') do
+        options[:debug] = true
+    end
+
+    options[:noop] = false
+    opts.on('-n', '--noop', 'Don\'t make changes') do
+        options[:noop] = true
+    end
+
+    options[:interface_cidr] = '0.0.0.0/0'
+    opts.on('-c', '--interface-cidr CIDR', 'Only consider interfaces matching the given CIDR') do |c|
+        options[:interface_cidr] = c
+    end
+
+    options[:connect_by_ip] = 0
+    opts.on('--connect-by-ip','Configure newly added hosts to connect by IP address instead of DNS') do
+        options[:connect_by_ip] = 1
+    end
+
+    options[:lockfile] = "/tmp/zcollective.lock"
+    opts.on('--lockfile=f', 'Use alternative lock file') do |f|
+        options[:lockfile] = f
+    end
+
+    options[:timeout] = 60
+    opts.on('--timeout=t', 'Time out after number of seconds') do |t|
+        options[:timeout] = t.to_i
+    end
+
+end
+
+begin
+
+    optparse.parse!
+
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+
+    $stderr.puts $!.to_s
+    $stderr.puts optparse
+    exit 2
+
+end
+
+log = Logger.new(STDERR)
+
+if options[:debug]
+    log.level = Logger::DEBUG
+else
+    log.level = Logger::INFO
+end
+
+trap("ALRM") do
+    log.info("Timeout after #{options[:timeout]}s")
+    exit 4
+end
+
+Thread.new {
+    sleep options[:timeout]
+    Process.kill( "ALRM", Process.pid )
+}
+
+if File.exist?(options[:lockfile])
+
+    other_pid = File.read(options[:lockfile]).to_i
+
+    begin
+        Process.getpgid( other_pid )
+        log.info("Another zcollective process (#{other_pid}) holds the lock")
+        exit 3  
+    rescue Errno::ESRCH
+        log.info("Deleting stale lock file")
+        FileUtils.remove_file(options[:lockfile], true)
+    end
+
+end
+
+File.open( options[:lockfile], File::CREAT | File::EXCL | File::WRONLY ) do |o|
+    o.write(Process.pid)
+end
+
+log.debug( "Connecting to Zabbix RPC service" )
+
+zabbix_client = ZCollective::ZabbixClient.new(
+    :url      => options[:zabbix_api_url],
+    :user     => options[:zabbix_user],
+    :password => options[:zabbix_pass],
+    :debug    => options[:debug]
+)
+
+log.debug( "Connected and authenticated" )
+
+
+
+############################################################################
+# Fetch list of zabbix templates
+
+log.debug( "Fetching list of zabbix templates" )
+
+zabbix_templates = {}
+
+zabbix_client.request( 'template.get', 
+    'search' => '', 
+    'output' => 'extend' 
+).each do |template|
+
+    log.debug( "\tName: #{template['name']} ID: #{template['templateid']}" )
+    zabbix_templates[ template['name'] ] = template['templateid']
+
+end
+
+# We're going to build a big nasty hash of zabbix and mcollective data
+# because apparently I still think like a Perl engineer.  It seems this
+# dirty bit of Ruby is necessary to allow them to be anonymously built.
+#
+nested_hash = lambda {|hash, key| hash[key] = Hash.new(&nested_hash)}
+hosts = Hash.new(&nested_hash)
+
+# An array of collectives to create hostgroups of:
+collectives = Array.new
+
+
+############################################################################
+# Fetch list of zabbix groups
+# Create "ZCollective discovered hosts" group if it doesn't exist
+
+log.debug( "Fetching list of zabbix hostgroups" )
+
+zcollective_hostgroup_name = 'ZCollective discovered hosts'
+zcollective_hostgroup      = nil
+
+zabbix_client.request( 'hostgroup.get',
+    'search' => '',
+    'output' => 'extend'
+).each do |hostgroup|
+
+    log.debug("\tName: #{hostgroup['name']} ID: #{hostgroup['groupid']}")
+
+    if hostgroup['name'] == zcollective_hostgroup_name
+        zcollective_hostgroup = hostgroup['groupid']
+    end
+
+end
+
+if zcollective_hostgroup.nil?
+
+    if options[:noop]
+
+        log.debug("No zcollective hostgroup, but not creating as " <<
+            "we're in --noop mode")
+
+    else
+
+        log.debug("No zcollective hostgroup: creating")
+
+        resp = zabbix_client.request( 'hostgroup.create',
+            'name' => zcollective_hostgroup_name
+        )
+
+        zcollective_hostgroup = resp['groupids'].first
+
+    end
+
+end
+
+log.debug("ZCollective hostgroup: #{zcollective_hostgroup}")
+
+
+
+############################################################################
+# Iterate through zabbix hosts
+
+zabbix_client.request( 'host.get', 
+    'search' => '', 
+    'output' => 'extend' 
+).each do |host|
+
+    log.debug( "Host: #{host['name']}, ID: #{host['hostid']}" )
+
+    # Iterate through hostinterfaces, looking for zabbix agent type
+    #  interfaces.
+    #
+    #  I'm not sure how we should handle multiple interfaces here
+    #   but it seems a safe assumption that there will only be one
+    #   agent type interface per machine.
+    
+    zabbix_client.request( 'hostinterface.get',
+        'hostids' => host['hostid'], 
+        'output'  => 'extend'
+    ).each do |interface|
+
+        next unless interface['type'] == "1" # skip non-Zabbix agent interfaces
+
+        log.debug( "\tIP: #{interface['ip']}" )
+        hosts[ host['name'] ][:zabbix][:ip] = interface['ip']
+
+    end
+
+    hosts[ host['name'] ][:zabbix][:hostid]    = host['hostid']
+    hosts[ host['name'] ][:zabbix][:templates] = []
+
+    # Iterate through this host's templates
+
+    zabbix_client.request(
+        'template.get',
+        'search'  => '',
+        'output'  => 'extend',
+        'hostids' => host['hostid']
+    ).each do |template|
+
+        log.debug( "\tTemplate: #{template['name']}" )
+        hosts[ host['name'] ][:zabbix][:templates].push( template['name'] )
+
+    end
+
+end
+
+
+
+############################################################################
+# Iterate through MCollective hosts
+
+include MCollective::RPC
+
+mc = rpcclient("rpcutil", :debug => true)
+begin
+zt_mc = rpcclient("zabbix_template", :exit_on_failure => false)
+rescue Exception
+    log.warn("No zabbix_template mcollective rpc agent found")
+end
+if (!zt_mc.nil?)
+    zt_mc.progress = false
+end
+mc.progress = false
+mc.discover.sort.each do |host|
+
+    # MCollective returns FQDN name, and we probably want to use the short
+    #  form name in zabbix.
+    
+    short_hostname = host.split('.').first
+
+    log.debug("Host: #{short_hostname} (#{host})")
+
+    # Get inventory details for each host
+    inventory = mc.custom_request( "inventory", {}, host,
+        { "identity" => host }
+    ).first
+
+    # Work through network interfaces reported by Facter and find the first
+    #  which matches the CIDR passed on the commandline.  Use that to talk
+    #  zabbix to.
+
+    cidr_to_match = NetAddr::CIDR.create( options[:interface_cidr] )
+    ip = nil
+
+    inventory[:data][:facts].sort.each do |key,value|
+
+        next unless key.match(/^ipaddress_/)
+
+        log.debug("Potential IP interface #{key} with IP #{value}")
+
+        ip_cidr = NetAddr::CIDR.create( value )
+        if ip_cidr.is_contained?( cidr_to_match) 
+
+           log.debug("IP matches CIDR #{options[:interface_cidr]}")
+
+           ip = value 
+           break
+
+        else
+            log.debug("IP doesn't match CIDR")
+        end
+
+    end
+
+    unless ip
+        raise "Host #{host} has no IP matching the target CIDR #{options[:interface_cidr]}" 
+    end
+
+    log.debug("\tIP #{ip}")
+
+    # Find whether we have to use different or any extra templates in Zabbix
+    # for any of the modules on this host. Only do this if we were
+    # successfully able to create the zabbix_template mcollective rpcclient.
+    if (!zt_mc.nil?)
+        host_template_info = zt_mc.custom_request( "templates", {},
+            host,
+            {"identity" => host}
+        ).first
+    end
+
+    if (!host_template_info.nil?)
+        hosts[ short_hostname ][:aliases]           = host_template_info[:data][:aliases]
+        hosts[ short_hostname ][:extras]            = host_template_info[:data][:extras]
+    end
+
+    hosts[ short_hostname ][:mcollective][:ip]      = ip
+    hosts[ short_hostname ][:mcollective][:classes] = inventory[:data][:classes]
+    hosts[ short_hostname ][:mcollective][:collectives] = inventory[:data][:collectives]
+
+    collectives << hosts[ short_hostname ][:mcollective][:collectives]
+
+end
+
+mc.disconnect
+
+###########################################################################
+# Fetch list of zabbix groups & Create hosts groups of discoverred
+# collectives, to add hosts to later
+
+log.debug("collectives: #{collectives.flatten.inspect}")
+log.debug("uniq collectives: #{collectives.flatten.uniq.inspect}")
+
+collectives_to_hostgroups = collectives.flatten.uniq
+
+collectives_to_hostgroups.each do | collective |
+
+    log.debug( "Fetching list of zabbix hostgroups" )
+
+    collective_hostgroup_name = "#{collective}"
+    collective_hostgroup_id   = nil
+
+    zabbix_client.request( 'hostgroup.get',
+        'search' => '',
+        'output' => 'extend'
+    ).each do |hostgroup|
+
+        log.debug("\tName: #{hostgroup['name']} ID: #{hostgroup['groupid']}")
+
+        if hostgroup['name'] == collective_hostgroup_name
+            collective_hostgroup_id = hostgroup['groupid']
+        end
+
+    end
+
+    if collective_hostgroup_id.nil?
+
+        if options[:noop]
+
+            log.debug("No #{collective} hostgroup, but not creating as " <<
+                "we're in --noop mode")
+        else
+
+            log.debug("No #{collective} hostgroup: creating")
+
+            resp = zabbix_client.request( 'hostgroup.create',
+                'name' => collective
+            )
+
+            collective_hostgroup_id = resp['groupids'].first
+
+        end
+
+    end
+
+    log.info("New hostgroup: #{collective}")
+    log.info("New hostgroup's ID: #{collective_hostgroup_id}")
+
+end
+
+
+############################################################################
+# Rationalise the two datasets, iterating over the hosts and carrying out
+# the appropriate actions
+
+hosts.each do |host,data|
+
+
+
+    ###### Condition 1 #############################################
+    #
+    # Hosts that are found by mcollective but that aren't in zabbix
+    #  should be added.
+    
+    if data.has_key?(:mcollective) and !data.has_key?(:zabbix)
+
+        log.info( "Host #{host} found by mcollective but not in zabbix" )
+
+        # If mcollective finds a host, but zabbix doesn't list one by
+        #  that name, we're going to add it.
+
+        # Iterate through the classes reported by mcollective for this
+        #  host. If the class name matches the name of a zabbix template,
+        #  get the ID and add an object to the templates_to_add array.
+        #  This will be passed to the zabbix API call.
+
+        templates_to_add = []
+        data[:mcollective][:classes].each do |template|
+            # if the class name has a :: in it, replace it with an underscore
+            # for the purposes of finding a template with that name
+            template = template.sub(/::/, '_')
+            classname = template
+
+            # if we have an alias for this template, use that instead
+            if ( ! data[:aliases].nil? and data[:aliases].has_key?( template ) )
+                template = data[:aliases][ template ]
+                log.debug("\tUsing alias #{template} for #{classname}")
+            end
+
+            next unless zabbix_templates.has_key?( template )
+            template_id = zabbix_templates[ template ]
+            log.debug("\tWill be adding template #{template} ID #{template_id}")
+            templates_to_add.push( { 'templateid' => template_id } )
+
+            # if we have any extra zabbix templates to add for this class
+            # then add them to the array of templates to add for this host
+            if ( ! data[:extras].nil? and data[:extras].has_key?( classname ) )
+
+                extra_templates = data[:extras][ classname ].split(/,/)
+
+                extra_templates.each do |extra_template|
+                    next unless zabbix_templates.has_key?( extra_template )
+                    template_id = zabbix_templates[ extra_template ]
+                    log.debug("\tWill be adding template #{extra_template} ID #{template_id} for #{classname}")
+                    templates_to_add.push( { 'templateid' => template_id } )
+                end
+
+            end
+        end
+
+        ### get list of current hostgroup, so we can add to the correct groups by ID
+        groups_by_id = []
+        zabbix_client.request( 'hostgroup.get',
+            'search' => '',
+            'output' => 'extend'
+        ).each do |hostgroup|
+
+            host_group_hash = {}
+
+            log.debug("\tName: #{hostgroup['name']} ID: #{hostgroup['groupid']}")
+
+            if data[:mcollective][:collectives].include? hostgroup['name']
+                host_group_hash['groupid'] = hostgroup['groupid']
+                groups_by_id << host_group_hash
+            end
+
+        end
+
+        if options[:noop]
+
+            log.info("--noop passed - not making changes")
+
+        else 
+
+            # If we're not in --noop mode, create the host with the
+            #  zabbix API.  Hosts need at least one interface (for now
+            #  we're just adding a Zabbix agent interface), and need
+            #  to be in a group.
+
+            resp = zabbix_client.request( 'host.create',
+                'host'       => host,
+                'interfaces' => [
+                    {
+                        'type'  => 1,
+                        'main'  => 1,
+                        'useip' => options[:connect_by_ip],
+                        'ip'    => data[:mcollective][:ip],
+                        'dns'   => host,
+                        'port'  => '10050'
+                    }
+                ],
+                'groups' => groups_by_id,
+                'templates' => templates_to_add
+            )
+
+            # This call returns the created host id
+
+            new_hostid = resp['hostids'].first
+
+            log.info("Host #{host} added as ID #{new_hostid} " <<
+                "with #{templates_to_add.count} templates")
+
+        end
+
+    end
+
+
+
+    ###### Condition 2 #############################################
+    # If zabbix contains a host that mcollective knows nothing about
+    #  we leave it alone but report it.
+
+    if data.has_key?(:zabbix) and !data.has_key?(:mcollective)
+
+        log.warn( "Host #{host} found in zabbix but not by mcollective" )
+
+    end
+
+
+
+    ###### Condition 3 #############################################
+    # Hosts in zabbix and mcollective are checked to ensure that 
+    #  they are linked with at least the templates they should be
+    
+    if data.has_key?(:zabbix) and data.has_key?(:mcollective)
+
+        log.debug( "Host #{host} in both zabbix and mcollective" )
+
+        # Compare interface addresses and warn if mismatched
+
+        if data[:mcollective][:ip] != data[:zabbix][:ip]
+            log.warn("Host #{host} monitored, but IP mismatch " <<
+                "M:#{data[:mcollective][:ip]} " <<
+                "Z:#{data[:zabbix][:ip]}"
+            )
+        end
+
+        templates_need_adding = []
+
+        # Iterate through the classes mcollective lists for the host
+
+        data[:mcollective][:classes].each do |template|
+
+            # templates_should_have is a list of templates that zabbix should have
+            # for this particular host, for this class.
+            templates_should_have = []
+
+            # Ignore any that don't match the name of a zabbix template
+            # Again, replace :: with _ to match template names
+            template = template.sub(/::/, '_')
+            classname = template
+
+            # if we have an alias for this template, use that instead
+            if ( ! data[:aliases].nil? and data[:aliases].has_key?( template ) )
+                template = data[:aliases][ template ]
+                log.debug("\tUsing alias #{template} for #{classname}")
+            end
+
+            next unless zabbix_templates.has_key?( template )
+            templates_should_have.push( template )
+            log.debug("\tHas mcollective class #{classname} matching a zabbix template")
+
+            # if we have any extra zabbix templates to add for this class
+            # then add them to the array of templates to add for this host
+            if ( ! data[:extras].nil? and data[:extras].has_key?( classname ) )
+
+                extra_templates = data[:extras][ classname ].split(/,/)
+
+                extra_templates.each do |extra_template|
+                    next unless zabbix_templates.has_key?( extra_template )
+                    template_id = zabbix_templates[ extra_template ]
+                    log.debug("\tHas extra template #{extra_template} defined for #{classname}")
+                    templates_should_have.push( extra_template )
+                end
+
+            end
+
+            # iterate over the templates that we should have, and if they're
+            # not already linked, add them to the list of templates which
+            # need adding for this host.
+            templates_should_have.each do |tpl_should_have|
+
+                if data[:zabbix][:templates].index( tpl_should_have )
+
+                    # The host in zabbix is already linked to this template
+                    log.debug("\tZabbix host already linked to template #{tpl_should_have}")
+
+                else
+    
+                    # Zabbix shows that although it knows about this template
+                    # the host in question isn't linked to it.  We add this
+                    # template to a list of those that are missing in zabbix.
+                    log.info("\tZabbix #{host} not linked to template #{tpl_should_have}")
+                    templates_need_adding.push( { 'templateid' => zabbix_templates[ tpl_should_have ] } )
+
+                end
+
+            end
+
+        end
+
+        if templates_need_adding.count > 0
+
+            if options[:noop]
+
+                log.info("--noop passed - not making changes")
+
+            else
+
+                # If we're not running --noop and we found missing templates,
+                #  link the zabbix host with these.
+
+                zabbix_client.request( 'template.massadd',
+                    'templates' => templates_need_adding,
+                    'hosts'     => { 'hostid' => data[:zabbix][:hostid] }
+                )
+
+                log.info("Added missing templates to #{host}")
+
+            end
+
+        end
+
+    end
+
+end
+
+FileUtils.remove_file(options[:lockfile], true)

data/lib/zcollective/zabbixclient.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2012, 2013, The Scale Factory Ltd.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#   * Neither the name of the The Scale Factory Ltd nor the
+#     names of its contributors may be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE SCALE FACTORY LTD BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'json'
+require 'net/http'
+require 'logger'
+require 'ostruct'
+
+module ZCollective
+
+    class ZabbixClient
+
+        @restclient_options = { :content_type => 'application/json' }
+
+        @url
+        @auth_hash
+        @options
+        @log
+
+        def initialize ( options = {} )
+            @options   = options
+
+            @log = Logger.new(STDERR)
+            if( @options[:debug] )
+                @log.level = Logger::DEBUG
+            else
+                @log.level = Logger::WARN
+            end
+
+            @auth_hash = authenticate
+
+        end
+
+        def authenticate ( )
+
+            response = request( 'user.authenticate',  
+                :user     => @options[:user], 
+                :password => @options[:password] 
+            )
+
+        end
+
+        def request_json( method, *args )
+
+            req = {
+                :jsonrpc => '2.0',
+                :method  => method,
+                :params  => Hash[*args.flatten],
+                :id      => rand( 100000 )
+            }
+
+            if @auth_hash
+                req[:auth] = @auth_hash
+            end
+
+            JSON.generate( req )
+
+        end
+
+        def request( method, *args ) 
+
+            json = request_json( method, *args )
+
+            uri  = URI.parse( @options[:url] )
+            proxy = ENV['http_proxy'] ? URI.parse(ENV['http_proxy']) : OpenStruct.new
+            http = Net::HTTP::Proxy(proxy.host, proxy.port).new( uri.host, uri.port )
+
+            request = Net::HTTP::Post.new( uri.request_uri )
+            request.add_field( 'Content-Type', 'application/json-rpc' )
+            request.body = json
+
+            @log.debug( "HTTP Request: #{uri} #{json}" )
+
+            response = http.request( request )
+
+            unless response.code == "200"
+                raise "HTTP Error: #{response.code}"
+            end
+
+            @log.debug( "HTTP Response: #{response.body}" )
+
+            result = JSON.parse( response.body )
+
+            if result['error']
+                raise "JSON-RPC error: #{result['error']['message']} (#{result['error']['data']})"
+            end
+
+            result['result']
+
+        end
+
+    end
+
+end
+

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: zcollective
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+  prerelease: 
+platform: ruby
+authors:
+- Jon Topper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: netaddr
+  requirement: &70263403228180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70263403228180
+description: ZCollective is a tool used to configure Zabbix using data discovered
+  using MCollective.
+email: jon@scalefactory.com
+executables:
+- zcollective
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/zcollective/zabbixclient.rb
+- bin/zcollective
+homepage: http://github.com/scalefactory/zcollective
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Zabbix/MCollective integration
+test_files: []
+has_rdoc: