zenoss_client 0.1.0 → 0.5.0

data/lib/zenoss/jsonapi/device_router.rb

@@ -0,0 +1,93 @@
+#############################################################################
+# Copyright © 2010 Dan Wanek <dwanek@nd.gov>
+#
+#
+# This file is part of zenoss_client.
+# 
+# zenoss_client is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or (at
+# your option) any later version.
+# 
+# zenoss_client is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+# Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License along
+# with zenoss_client.  If not, see <http://www.gnu.org/licenses/>.
+#############################################################################
+module Zenoss
+  module JSONAPI
+    module DeviceRouter
+
+      # @param [String] uid The organizer path to fetch devices from. This can be a
+      #   devclass, group, system, or location.
+      # @param [Hash] opts optional arguments to pass to getDevices
+      # @option opts [Fixnum] :start Offset to return the results from; used in pagination (default: 0)
+      # @option opts [Fixnum] :limit Number of items to return; used in pagination (default: 50)
+      # @option opts [String] :sort_key Key on which to sort the return results (default: 'name')
+      # @option opts [String] :sort_ord Sort order; can be either 'ASC' or 'DESC' (default: 'ASC')
+      # @option opts [Hash] :params Key-value pair of filters for this search. Can be one of the following: (default: {})
+      # @option :params [String] :name
+      # @option :params [String] :ipAddress
+      # @option :params [String] :deviceClass the device class not including the 'Devices' part, for instance '/Server/Linux'
+      # @option :params [String] :productionState
+      def get_devices(uid = '/zport/dmd/Devices', opts = {})
+        uid = "/zport/dmd#{uid}" unless uid.start_with?('/zport/dmd')
+        data = { :uid => uid }
+        data[:start]  = opts[:start] if opts.has_key? :start
+        data[:limit]  = opts[:limit] if opts.has_key? :limit
+        data[:sort]   = opts[:sort_key] if opts.has_key? :sort_key
+        data[:dir]    = opts[:sort_ord] if opts.has_key? :sort_ord
+        data[:params] = opts[:params] if opts.has_key? :params
+        resp = json_request('DeviceRouter', 'getDevices', [data])
+
+        devs = []
+        resp['devices'].each do |dev|
+          devs << Model::Device.new(self, dev)
+        end
+        devs
+      end
+
+      def get_templates(device_id)
+        resp = json_request('DeviceRouter', 'getTemplates', [{:id => device_id}])
+      end
+
+      def get_info(device_id, keys = nil)
+        data = {}
+        data[:uid]  = device_id
+        data[:keys] = keys if keys
+        resp = json_request('DeviceRouter', 'getInfo', [data])
+      end
+
+      # =============== Non-API Helper methods ===============
+
+      # This method will allow you to search for devices by name. If you put a partial name
+      #   it will return all matching entries. For example:
+      #   find_devices_by_name 'mydev' will return all devices that start with mydev
+      # @param [String] name the name of the device to search for
+      # @param [Hash] opts options to help limit device search
+      # @option opts [String] :deviceClass the device class to limit the search to
+      # @option opts [String] :productionState the production state to limit the search to
+      # @return [Array] an array of devices found or an empty array if nothing is matched
+      def find_devices_by_name(name, opts={})
+        opts[:name] = name
+        get_devices('/zport/dmd/Devices', :params => opts)
+      end
+
+      # This method will find a device for the given IP Address or all matching devices
+      #   given a partial IP.
+      # @param [String] ip the ip address of the device to search for
+      # @param [Hash] opts options to help limit device search
+      # @option opts [String] :deviceClass the device class to limit the search to
+      # @option opts [String] :productionState the production state to limit the search to
+      # @return [Array] an array of devices found or an empty array if nothing is matched
+      def find_devices_by_ip(ip, opts={})
+        opts[:ipAddress] = ip
+        get_devices('/zport/dmd/Devices', :params => opts)
+      end
+
+    end # DeviceRouter
+  end # JSONAPI
+end # Zenoss

data/lib/{events/event.rb → zenoss/jsonapi/events_router.rb}

@@ -17,19 +17,31 @@
 # You should have received a copy of the GNU General Public License along
 # with zenoss_client.  If not, see <http://www.gnu.org/licenses/>.
 #############################################################################
-
 module Zenoss
-  module Event
-    class Event
-      include Zenoss
-      def initialize(event_hash)
-        event_hash.each_pair do |key,value|
-          instance_variable_set("@#{key}",value)
-          self.class.send(:define_method, key, proc { instance_variable_get("@#{key}")})
+  module JSONAPI
+    module EventsRouter
+
+      def get_events(device=nil, component=nil, event_class=nil, limit=100)
+        data = {
+          :start  => 0,
+          :limit  => 100,
+          :dir    => 'DESC',
+          :sort   => 'severity',
+          :params => { :severity => [5,4,3,2,1], :eventState => [0,1]},
+        }
+        data[:params][:device] = device if device
+        data[:params][:component] = component if component
+        data[:params][:eventClass] = event_class if event_class
+
+        resp = json_request('EventsRouter', 'query', [data])
+
+        events = []
+        resp['events'].each do |ev|
+          events << Events::ZEvent.new(self, ev)
         end
+        events
       end
-    end # Event
-  end # Event
-end # Zenoss
 
-require 'events/zevent'
+    end # EventsRouter
+  end # JSONAPI
+end # Zenoss

data/lib/{model/events/mysql_event_manager.rb → zenoss/jsonapi/report_router.rb}

@@ -18,19 +18,17 @@
 # with zenoss_client.  If not, see <http://www.gnu.org/licenses/>.
 #############################################################################
 module Zenoss
-  module Model
-    module Events
-      class MySqlEventManager < EventManagerBase
-        include Zenoss::Model
+  module JSONAPI
+    module ReportRouter
 
-        def initialize(manager_base)
-          super(manager_base)
-        end
+      def get_report_types
+        resp = json_request('ReportRouter', 'getReportTypes')
+      end
 
+      def get_report_tree(id = '/zport/dmd/Reports')
+        resp = json_request('ReportRouter', 'getTree', [{:id => id}])
+      end
 
-        # ------------------ REST Calls ------------------ #
-
-      end # MySqlEventManager
-    end # Events
-  end # Model
+    end # ReportRouter
+  end # JSONAPI
 end # Zenoss

data/lib/{model → zenoss}/model.rb

@@ -45,23 +45,19 @@ module Zenoss
   end # Model
 end # Zenoss
 
-require 'model/event_view'
-require 'model/rrd_view'
+require 'zenoss/model/event_view'
+require 'zenoss/model/rrd_view'
 
 # Device Loader interface.  You can use it directly or use the
 # utility methods in DeviceClass to create devices beneath
 # that class
-require 'model/z_device_loader'
+require 'zenoss/model/z_device_loader'
 
 # Device Related ( /zport/dmd/Devices )
-require 'model/devices'
-
-# Event Related
-require 'model/events/event_manager_base'
-require 'model/events/mysql_event_manager'
+require 'zenoss/model/devices'
 
 # Service Related ( /zport/dmd/Services )
-require 'model/services'
+require 'zenoss/model/services'
 
 # Systems Related ( /zport/dmd/Systems )
-require 'model/systems'
+require 'zenoss/model/systems'

data/lib/{model → zenoss/model}/devices.rb

@@ -47,7 +47,7 @@ end # Zenoss
 
 
 # Load the main Device related files
-require 'model/devices/device_class'
-require 'model/devices/device'
-require 'model/devices/device_hw'
-require 'model/devices/operating_system'
+require 'zenoss/model/devices/device_class'
+require 'zenoss/model/devices/device'
+require 'zenoss/model/devices/device_hw'
+require 'zenoss/model/devices/operating_system'

data/lib/{model → zenoss/model}/devices/device.rb

@@ -19,38 +19,33 @@
 #############################################################################
 module Zenoss
   module Model
-    class Device
+    class Device < OpenStruct
       include Zenoss::Model
       include Zenoss::Model::EventView
       include Zenoss::Model::RRDView
       include Zenoss::Model::DeviceResultInt
 
-      attr_reader :path, :device, :os, :hw
-
-      def initialize(device_path)
-        device_path.sub(/^\/zport\/dmd\/(.*)\/([^\/]+)$/) do |m|
-          @path = $1
-          @device = $2
-        end
-
-        @os = OperatingSystem.new(self)
-        @hw = DeviceHW.new(self)
-
-        # Initialize common things from Model
-        model_init
+      # Initialize this object from a Hash returned via getDevices from the JSON api
+      # @param[Zenoss] zenoss the current instance we are connecting with
+      # @param[Hash] zhash a hash of values used to create this Device instance
+      def initialize(zenoss,zhash)
+        @zenoss = zenoss
+        super zhash
+        self.ipAddress = IPAddr.new(IPAddr.inet_ntoa(self.ipAddress)) if self.ipAddress
       end
 
+      # -------------------- JSON API Calls ------------------- #
 
-      # ------------------ Custom REST Calls ------------------ #
-      # These are not part of the official Zenoss API
-
+      # Get events for this device
       def get_events
-        get_event_manager.get_event_list(nil,"device='#{@device}'")
+        @zenoss.get_events(self.name)
       end
 
+      def get_info(keys = nil)
+        @zenoss.get_info(self.uid, keys)
+      end
 
-
-      # ------------------ REST Calls ------------------ #
+      # ------------------ Legacy REST Calls ------------------ #
 
       # Move this Device to the given DeviceClass.
       def change_device_class(device_class)
@@ -206,7 +201,11 @@ module Zenoss
       private
 
       def rest(method)
-        super("#{@path}/#{@device}/#{method}")
+        @zenoss.rest(URI.encode("#{self.uid}/#{method}"))
+      end
+
+      def custom_rest(req_path, callback_func = nil, callback_attr=nil)
+        @zenoss.custom_rest(self.uid, req_path, callback_func, callback_attr)
       end
 
     end # Device

data/lib/{model → zenoss/model}/rrd/rrd_data_point.rb

@@ -19,17 +19,20 @@
 #############################################################################
 module Zenoss
   module Model
-    class RRDDataPoint
+    class RRDDataPoint < OpenStruct
       include Zenoss
       include Zenoss::Model
 
-      def initialize(datapoint_path)
-        @path = datapoint_path
-
-        # Initialize common things from Model
+      def initialize(zenoss, datapoint_path)
+        @zenoss = zenoss
+        super({:uid => datapoint_path})
         model_init
       end
 
+      # -------------------- JSON API Calls ------------------- #
+
+
+
       # ------------------------- Utility Methods ------------------------- #
       # These are methods that do not exist as part of the official Zenoss
       # API, but from an object model they seem to make sense to me.
@@ -47,8 +50,8 @@ module Zenoss
 
       private
 
-      def rest(method, path = "#{@path}")
-        super("#{path}/#{method}")
+      def rest(method)
+        @zenoss.rest(URI.encode("#{self.uid}/#{method}"))
       end
 
     end # DeviceClass

data/lib/zenoss/model/rrd_view.rb

@@ -0,0 +1,93 @@
+#############################################################################
+# Copyright © 2010 Dan Wanek <dwanek@nd.gov>
+#
+#
+# This file is part of zenoss_client.
+# 
+# zenoss_client is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or (at
+# your option) any later version.
+# 
+# zenoss_client is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+# Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License along
+# with zenoss_client.  If not, see <http://www.gnu.org/licenses/>.
+#############################################################################
+module Zenoss
+  module Model
+    module RRDView
+      include Zenoss::Model
+
+      # @return [Array] of datapoints
+      def get_rrd_data_points
+        (plist_to_array( custom_rest('getRRDDataPoints').chomp )).map do |dstr|
+          dp = dstr.sub(/^<([\w]+)\s+at\s+(.*)>$/,'\2')
+          RRDDataPoint.new(@zenoss,dp)
+        end
+      end
+
+      # Get key/value pairs of RRD Values for the passed data source names.
+      #
+      # @param [Array <String>] dsnames data source names from RRDDataPoint#name
+      # @return [Hash] key/value pairs of data source name and data source values
+      def get_rrd_values(dsnames)
+        pdict_to_hash(custom_rest("getRRDValues?dsnames=[#{dsnames.join(',')}]"))
+      end
+
+      # Get all of the data point falues between a certain time period
+      # @param [String] dpname the name of the data point to retrieve values for
+      # @param [String] cf the RRD consolidation function to use
+      #   AVERAGE,MIN,MAX,LAST
+      # @param [Fixnum] resolution the RRD resolution to use. This is the interval
+      #   between values. It defaults to 300 seconds (5 minutes).
+      # @param [DateTime] start the time to begin fetching values from
+      # @param [DataTime] end the time to stop fetching values at. It defaults to now.
+      # @example An example of the actuall HTTP call
+      #   http://myhost:8080/zport/dmd/Devices/path/callZenossMethod?methodName=fetchRRDValue&args=[my_dpoint===AVERAGE===300===1300761000===1300776100]
+      def fetch_rrd_value(dpname,vstart,vend=DateTime.now,cf='AVERAGE',resolution=300)
+        method =  "fetchRRDValue?dpname=#{dpname}"
+        method << "&cf=#{cf}&resolution=#{resolution}"
+        method << "&start=#{vstart.strftime('%s')}"
+        method << "&end=#{vend.strftime('%s')}"
+        custom_rest(method)
+        parse_rrd_fetch(custom_rest(method))
+      end
+
+      #private
+
+
+      # Parse the string returned by the REST call fetchRRDValue.
+      def parse_rrd_fetch(vstr)
+        vstr = vstr.chomp
+        vstr = vstr.slice 1, (vstr.length - 2)
+        parts = vstr.match(/^\(([^\)]+)\),\s*\(([^\)]+)\),\s*\[([^\]]+)\]/)
+
+        # Get the first part of the return, start, end, resolution
+        retparms = Hash[[:start,:end,:resolution].zip( parts[1].split(/\s*,\s*/).map {|v| v.to_i} )]
+        # Get the datasource name. This will almost always be 'ds0'
+        retparms[:rrdds] = parts[2].gsub(/['"]/,'').split(/,/).first
+        # Get the values
+        retparms[:rrdvalues] = plist_to_array(parts[3]).map do |v|
+          atom = v.gsub(/(\(|\))/,'').split(/\s*,\s*/)[0]
+          case atom
+          when /\d\.\d/
+            atom.to_f
+          when /^\d$/
+            atom.to_i
+          when /None/
+            nil
+          end
+        end
+        retparms
+      end
+
+    end # RRDView
+  end # Model
+end # Zenoss
+
+# Load the RRD related files
+require 'zenoss/model/rrd/rrd_data_point'

data/lib/{model → zenoss/model}/services.rb

@@ -17,8 +17,8 @@
 # You should have received a copy of the GNU General Public License along
 # with zenoss_client.  If not, see <http://www.gnu.org/licenses/>.
 #############################################################################
-require 'model/services/service_organizer'
-require 'model/services/service_class'
-require 'model/services/service'
-require 'model/services/ip_service'
-require 'model/services/win_service'
+require 'zenoss/model/services/service_organizer'
+require 'zenoss/model/services/service_class'
+require 'zenoss/model/services/service'
+require 'zenoss/model/services/ip_service'
+require 'zenoss/model/services/win_service'