lm_rest 1.0.6 → 1.0.7

data/lib/lm_rest/api_client.rb

@@ -3,10 +3,23 @@ require 'base64'
 require 'openssl'
 require 'rest-client'
 require 'json'
+require 'uri'
 require 'lm_rest/resource'
 require 'lm_rest/request_params'
 
 module LMRest
+  class APIError < StandardError
+    attr_reader :status, :body, :headers
+
+    def initialize(response)
+      @status = response.code
+      @body = response.body
+      @headers = response.headers
+
+      super("LogicMonitor API request failed with status #{@status}")
+    end
+  end
+
   class APIClient
     include RequestParams
 
@@ -39,19 +52,14 @@ module LMRest
       uri.split("?")[0].split("/").join("/")
     end
 
-    def sign(method, uri, data = nil)
-
+    def sign(method, uri, data = nil, content_type = 'application/json')
       resource_uri = uri_to_resource_uri(uri)
 
       time = DateTime.now.strftime('%Q')
 
       http_method = method.to_s.upcase
 
-      if data.nil? || data.empty?
-        data = ''
-      else
-        data = data.to_json.to_s
-      end
+      data = data_for_signature(data, content_type)
 
       message =  "#{http_method}#{time}#{data}#{resource_uri}"
 
@@ -66,45 +74,67 @@ module LMRest
       "LMv1 #{access_id}:#{signature}:#{time}"
     end
 
-    def request(method, uri, params={})
-      headers = {}
-      headers['Authorization'] = sign(method, uri, params)
-      headers['Content-Type'] = 'application/json'
-      headers['Accept'] = 'application/json, text/javascript'
-      headers['X-version'] = '3'
-
+    def request(method, uri, params = nil, content_type: 'application/json')
+      headers = build_headers(method, uri, params, content_type)
       url = api_url + uri
-      #puts "URL: " + url
-      #puts headers
-
-      json_params = params.to_json
-
-      begin
-        case method
-        when :get
-          response = RestClient.get(url, headers)
-        when :post
-          response = RestClient.post(url, json_params, headers)
-        when :put
-          response = RestClient.put(url, json_params, headers)
-        when :delete
-          response = RestClient.delete(url, headers: headers)
+      payload = serialize_payload(params, content_type)
+
+      response = execute_request(method.to_sym, url, payload, headers)
+      handle_response(response)
+
+      parse_response(response)
+    end
+
+    def build_headers(method, uri, params, content_type)
+      headers = {
+        'Authorization' => sign(method, uri, params, content_type),
+        'Accept' => 'application/json, text/javascript',
+        'X-version' => '3'
+      }
+
+      headers['Content-Type'] = content_type unless multipart_form?(content_type)
+      headers
+    end
+
+    def execute_request(method, url, payload, headers)
+      case method
+      when :get
+        RestClient.get(url, headers)
+      when :post
+        RestClient.post(url, payload, headers)
+      when :put
+        RestClient.put(url, payload, headers)
+      when :patch
+        RestClient.patch(url, payload, headers)
+      when :delete
+        if payload.nil?
+          RestClient.delete(url, headers)
+        else
+          RestClient::Request.execute(method: :delete, url: url, payload: payload, headers: headers)
         end
-      rescue => e
-        puts e.http_body
-        raise
+      else
+        raise ArgumentError, "unsupported HTTP method: #{method}"
       end
+    end
 
-      if response.code != 200
-        puts response.code.to_s + ":" + response.body.to_s
-        raise
-      end
+    def handle_response(response)
+      raise APIError.new(response) unless response.code.between?(200, 299)
+
+      @limit = response.headers[:x_rate_limit_limit] || response.headers['x_rate_limit_limit']
+      @remaining = response.headers[:x_rate_limit_remaining] || response.headers['x_rate_limit_remaining']
+      @window = response.headers[:x_rate_limit_window] || response.headers['x_rate_limit_window']
+    end
 
-      @limit = response.headers['x_rate_limit_limit']
-      @remaining = response.headers['x_rate_limit_remaining']
-      @window = response.headers['x_rate_limit_window']
+    def parse_response(response)
+      return nil if response.body.nil? || response.body.empty?
 
-      JSON.parse(response.body)
+      content_type = response.headers[:content_type] || response.headers['content_type']
+
+      if content_type.to_s.include?('application/json')
+        JSON.parse(response.body)
+      else
+        response.body
+      end
     end
 
     # Handles making multiple requests to the API if pagination is necessary.
@@ -114,70 +144,59 @@ module LMRest
     # If you need to walk through resources page-by-page manullay, use the
     # request() method with the 'offset' and 'size' params
     #
-    def paginate(uri, params)
-
-      # Hooray for pagination logic!
-      if (params[:size] == 0 || params[:size].nil? || params[:size] > ITEMS_SIZE_LIMIT)
-        # save user-entered size in a param for use later
-        user_size = params[:size]
-
-        # set our size param to the max
-        params[:size] = ITEMS_SIZE_LIMIT
-
-        # Set our offset to grab the first page of results 
-        params[:offset] ||= 0
-
-        # make the initial request
-        body = request(:get, uri.call(params), nil)
-
-        # pull the actual items out of the request body and into our
-        # item_collector while we build up the items list
-        item_collector = body['items']
-
-        # The API sends the total number of objects back in the first request.
-        # We need this to determine how many more pages to pull
-        total = body['total']
-
-        # If user didn't pass size param, set it to total
-        # This just means you'll get all items if not specifying a size
-        user_size ||= total
-
-        # If the user passed a size larger than what's available, set it to
-        # total to retrieve all items
-        if user_size > total
-          user_size = total
-        end
+    def paginate(uri, params, method = :get, payload = nil, content_type = 'application/json')
+      params = normalize_params_hash(params)
+      user_size = params[:size]&.to_i
+      params[:size] = user_size && user_size < ITEMS_SIZE_LIMIT ? user_size : ITEMS_SIZE_LIMIT
+      params[:offset] = (params[:offset] || 0).to_i
+
+      body = request(method, uri.call(params), payload, content_type: content_type)
+      return body unless body.is_a?(Hash) && body.key?('items')
+
+      total = (body['total'] || body['items'].length).to_i
+      user_size = determine_user_size(user_size, total)
+      item_collector = body['items'].first(user_size)
+
+      while item_collector.length < user_size
+        params[:offset] += params[:size].to_i
+        remaining = user_size - item_collector.length
+        params[:size] = [remaining, ITEMS_SIZE_LIMIT].min
+        body = request(method, uri.call(params), payload, content_type: content_type)
+        break unless body.is_a?(Hash) && body.key?('items')
+        break if body['items'].empty?
+
+        item_collector.concat(body['items'].first(remaining))
+      end
 
-        # calculate the remaining number of items (after first request)
-        # then use that to figure out how many more times we need to call
-        # request() to get all the items, then do it
-        pages_remaining = ((user_size - ITEMS_SIZE_LIMIT).to_f/ITEMS_SIZE_LIMIT).ceil
+      body['items'] = item_collector
+      body
+    end
 
-        pages_remaining.times do |page|
+    def determine_user_size(user_size, total)
+      user_size ||= total
+      user_size > total ? total : user_size
+    end
 
-          # Increment the offset by the limit to get the next page
-          params[:offset] += ITEMS_SIZE_LIMIT
+    def self.define_operation_methods(operations)
+      operations.each do |method_name, operation|
+        define_operation_method(method_name, operation)
+      end
+    end
 
-          # if this is the last page, get the remainder
-          if page == pages_remaining - 1
-            params[:size]  = user_size%ITEMS_SIZE_LIMIT
-          else
-            # else, get a whole page
-            params[:size] = ITEMS_SIZE_LIMIT
-          end
+    def self.define_operation_method(method_name, operation)
+      define_method(method_name) do |*args|
+        perform_operation(operation, args)
+      end
+    end
 
-          # make a subsequent request with modified params
-          body = request(:get, uri.call(params), nil)
+    def self.define_alias_methods(aliases)
+      aliases.each do |alias_name, target_name|
+        next if alias_name == target_name
+        next unless method_defined?(target_name)
 
-          # add these items to our item_collector
-          item_collector += body['items']
+        define_method(alias_name) do |*args|
+          public_send(target_name, *args)
         end
-
-        body['items'] = item_collector
-        body
-      else
-        # No pagination required, just request the page
-        request(:get, uri.call(params), nil)
       end
     end
 
@@ -189,78 +208,74 @@ module LMRest
       attributes['actions'].each do |action|
         case action
         when 'get'
+          define_get_methods(resource_uri, singular, plural)
+        when 'add'
+          define_add_method(resource_uri, singular)
+        when 'update'
+          define_update_method(resource_uri, singular)
+        when 'delete'
+          define_delete_method(resource_uri, singular)
+        end
+      end
+    end
 
-          uri = lambda { |params| "#{resource_uri}#{RequestParams.parameterize(params)}"}
+    def self.define_get_methods(resource_uri, singular, plural)
+      uri = lambda { |params| "#{resource_uri}#{RequestParams.parameterize(params)}" }
 
-          unless plural.nil?
-            # Define a method to fetch multiple resources with optional params
-            define_method("get_#{plural}") do |params = {}|
-              Resource.parse paginate(uri, params)
-            end
-          end
-
-          # Define a method to get one resource by it's id number, with optional
-          # params, thought now that I think about it I'm not sure why you'd pass
-          # params when grabbing just one resource.
-
-          # Some resources are Singletons
-          unless singular.nil?
-            define_method("get_#{singular}") do |*args|
-              case args.size
-              when 0
-                Resource.parse request(:get, "#{resource_uri}", nil)
-              when 1
-                Resource.parse request(:get, "#{resource_uri}/#{args[0]}", nil)
-              when 2
-                Resource.parse request(:get, "#{resource_uri}/#{args[0]}#{RequestParams.parameterize(args[1])}", nil)
-              else
-                raise ArgumentError.new("wrong number for arguments (#{args.count} for 1..2)")
-              end
-            end
-          end
+      define_plural_get_method(uri, plural) unless plural.nil?
+      define_singular_get_method(resource_uri, singular) unless singular.nil?
+    end
 
-        when 'add'
+    def self.define_plural_get_method(uri, plural)
+      define_method("get_#{plural}") do |params = {}|
+        Resource.parse paginate(uri, params)
+      end
+    end
 
-          # Define a method to add a new resource to the account
-          define_method("add_#{singular}") do |properties|
-            if properties.class == LMRest::Resource
-              Resource.parse request(:post, "#{resource_uri}", properties.to_h)
-            else
-              Resource.parse request(:post, "#{resource_uri}", properties)
-            end
-          end
+    def self.define_singular_get_method(resource_uri, singular)
+      define_method("get_#{singular}") do |*args|
+        case args.size
+        when 0
+          Resource.parse request(:get, "#{resource_uri}", nil)
+        when 1
+          Resource.parse request(:get, "#{resource_uri}/#{args[0]}", nil)
+        when 2
+          Resource.parse request(:get, "#{resource_uri}/#{args[0]}#{RequestParams.parameterize(args[1])}", nil)
+        else
+          raise ArgumentError.new("wrong number for arguments (#{args.count} for 1..2)")
+        end
+      end
+    end
 
-        when 'update'
+    def self.define_add_method(resource_uri, singular)
+      define_method("add_#{singular}") do |properties|
+        properties_hash = properties.is_a?(LMRest::Resource) ? properties.to_h : properties
+        Resource.parse request(:post, "#{resource_uri}", properties_hash)
+      end
+    end
 
-          # Define a method to update a resource
-          define_method("update_#{singular}") do |id, properties = {}|
-            if id.class == LMRest::Resource
-              Resource.parse request(:put, "#{resource_uri}/#{id.id}", id.to_h)
-            else
-              Resource.parse request(:put, "#{resource_uri}/#{id}", properties)
-            end
-          end
+    def self.define_update_method(resource_uri, singular)
+      define_method("update_#{singular}") do |id, properties = {}|
+        if id.is_a?(LMRest::Resource)
+          properties = id.to_h if properties.empty?
+          id = id.id
+        end
 
-        when 'delete'
+        Resource.parse request(:put, "#{resource_uri}/#{id}", properties)
+      end
+    end
 
-          # Define a method to delete the resource
-          define_method("delete_#{singular}") do |id|
-            if id.class == LMRest::Resource
-              id = id.id
-              Resource.parse request(:delete, "#{resource_uri}/#{id}", nil)
-            else
-              Resource.parse request(:delete, "#{resource_uri}/#{id}", nil)
-            end
-          end
-        end
+    def self.define_delete_method(resource_uri, singular)
+      define_method("delete_#{singular}") do |id, params = {}|
+        id = id.id if id.is_a?(LMRest::Resource)
+        uri = "#{resource_uri}/#{id}#{RequestParams.parameterize(params)}"
+        Resource.parse request(:delete, uri, nil)
       end
     end
 
     def self.define_child_methods(resource_type, attributes)
       parent_singular = attributes['method_names']['singular']
-      parent_plural = attributes['method_names']['plural']
       parent_resource_uri = attributes['url']
-      parent_id = attributes['parent_id_key']
       children = attributes['children']
 
       children.each do |child_name|
@@ -275,39 +290,56 @@ module LMRest
         child_resource_uri = attributes['url'].split("/").last
 
         child['actions'].each do |action|
-          case action
-          when 'get'
-
+            case action
+            when 'get'
             define_method("get_#{parent_singular}_#{child_plural}") do |id, params = {}, &block|
               uri = lambda { |params| "#{parent_resource_uri}/#{id}/#{child['method_names']['plural']}#{RequestParams.parameterize(params)}" }
               Resource.parse paginate(uri, params)
             end
 
-          when 'add'
-          when 'update'
-          when 'delete'
-          end
+            when 'add'
+            define_method("add_#{parent_singular}_#{child_singular}") do |parent_id, properties|
+              properties_hash = properties.is_a?(LMRest::Resource) ? properties.to_h : properties
+              Resource.parse request(:post, "#{parent_resource_uri}/#{parent_id}/#{child_resource_uri}", properties_hash)
+            end
+
+            when 'update'
+            define_method("update_#{parent_singular}_#{child_singular}") do |parent_id, child_id, properties = {}|
+              Resource.parse request(:put, "#{parent_resource_uri}/#{parent_id}/#{child_resource_uri}/#{child_id}", properties)
+            end
+
+            when 'delete'
+            define_method("delete_#{parent_singular}_#{child_singular}") do |parent_id, child_id|
+              Resource.parse request(:delete, "#{parent_resource_uri}/#{parent_id}/#{child_resource_uri}/#{child_id}", nil)
+            end
+            end
         end
       end
     end
 
     # Define methods based on the JSON structure
     def self.setup
+      return if @api_methods_defined
+
       @@api_definition_path = File.expand_path(File.join(File.dirname(__FILE__), "../../api.json"))
       @@api_json = JSON.parse(File.read(@@api_definition_path))
-      @@api_json.each do |resource_type, attributes|
-        define_action_methods(resource_type, attributes) if attributes['actions']
-        define_child_methods(resource_type, attributes) if attributes['children']
+
+      if @@api_json['operations']
+        define_operation_methods(@@api_json['operations'])
+        define_alias_methods(@@api_json['aliases'] || {})
+      else
+        @@api_json.each do |resource_type, attributes|
+          define_action_methods(resource_type, attributes) if attributes['actions']
+          define_child_methods(resource_type, attributes) if attributes['children']
+        end
       end
+
+      @api_methods_defined = true
     end
 
     # Ack a down collector, pass the ID and a comment
     def ack_collector_down(id, comment)
-      if id.class == LMRest::Resource
-        Resource.parse request(:post, "/setting/collectors/#{id.id}/ackdown", {comment: comment})
-      else
-        Resource.parse request(:post, "/setting/collectors/#{id}/ackdown", {comment: comment})
-      end
+      ack_collector_down_alert_by_id(resource_id(id), comment: comment)
     end
 
     # run a report
@@ -319,8 +351,215 @@ module LMRest
       end
     end
 
+    # Helper to return execution counts for all websites across a time window.
+    # Assumes website interval is in minutes and locations/checkpoints is an array
+    # or comma-separated list.
+    def website_execution_stats(days = 30)
+      raise ArgumentError, "days must be positive" if days <= 0
+
+      websites = get_websites
+
+      per_site = websites.map do |site|
+        interval = website_interval_minutes(site)
+        location_count = website_location_count(site)
+        next if interval.nil? || interval <= 0
+
+        executions = (days * 24 * 60.0 / interval * location_count).ceil
+
+        {
+          id: site.respond_to?(:id) ? site.id : nil,
+          name: site.respond_to?(:name) ? site.name : nil,
+          interval_minutes: interval,
+          location_count: location_count,
+          executions: executions
+        }
+      end.compact
+
+      {
+        days: days,
+        website_count: per_site.count,
+        total_executions: per_site.sum { |row| row[:executions] },
+        websites: per_site
+      }
+    end
+
     private
 
     attr_accessor :access_key
+
+    def perform_operation(operation, args)
+      path_values, body, query_params = coerce_operation_arguments(operation, args)
+      content_type = request_content_type(operation)
+      method = operation['method'].to_sym
+      uri = lambda { |params| operation_uri(operation, path_values, params) }
+
+      response =
+        if operation_paginated?(operation)
+          paginate(uri, query_params, method, body, content_type)
+        else
+          request(method, uri.call(query_params), body, content_type: content_type)
+        end
+
+      Resource.parse(response)
+    end
+
+    def coerce_operation_arguments(operation, args)
+      args = args.dup
+      path_param_names = operation['path_params'] || []
+      has_body = !!operation['body_param']
+      query_params = {}
+      inferred_body = nil
+
+      if has_body
+        if args.length > path_param_names.length + 1 && args.last.is_a?(Hash)
+          query_params = args.pop
+        elsif !operation['body_required'] &&
+              args.length == path_param_names.length + 1 &&
+              args.last.is_a?(Hash) &&
+              query_params_only?(args.last, operation)
+          query_params = args.pop
+        end
+
+        if path_param_names.length == 1 &&
+           args.length == 1 &&
+           resource_like?(args.first) &&
+           %w[put patch].include?(operation['method'])
+          inferred_body = args.first
+        end
+      elsif args.length > path_param_names.length && args.last.is_a?(Hash)
+        query_params = args.pop
+      end
+
+      path_values = path_param_names.map do
+        value = args.shift
+        value = inferred_body if value.nil?
+        resource_id(value)
+      end
+
+      if path_values.any?(&:nil?)
+        raise ArgumentError, "#{operation['name']} requires path params: #{path_param_names.join(', ')}"
+      end
+
+      body = nil
+      if has_body
+        body_arg = args.shift || inferred_body
+        if body_arg.nil? && operation['body_required']
+          raise ArgumentError, "#{operation['name']} requires a request body"
+        end
+        body = resource_to_hash(body_arg) unless body_arg.nil?
+      end
+
+      unless args.empty?
+        raise ArgumentError, "wrong number of arguments for #{operation['name']}"
+      end
+
+      [path_values, body, normalize_params_hash(query_params)]
+    end
+
+    def operation_uri(operation, path_values, query_params)
+      uri = operation['path'].dup
+
+      (operation['path_params'] || []).zip(path_values).each do |name, value|
+        uri.gsub!("{#{name}}", URI.encode_www_form_component(value.to_s))
+      end
+
+      "#{uri}#{RequestParams.parameterize(query_params)}"
+    end
+
+    def request_content_type(operation)
+      Array(operation['consumes']).find { |type| type && !type.empty? } || 'application/json'
+    end
+
+    def operation_paginated?(operation)
+      operation['paginated'] || (operation['method'] == 'get' && operation['paginated_response'])
+    end
+
+    def normalize_params_hash(params)
+      return {} if params.nil?
+
+      params.each_with_object({}) do |(key, value), normalized|
+        normalized[key.to_sym] = value
+      end
+    end
+
+    def query_params_only?(params, operation)
+      query_param_names = operation['query_params'] || []
+      return false if query_param_names.empty?
+
+      params.keys.all? { |key| query_param_names.include?(key.to_s) }
+    end
+
+    def resource_like?(value)
+      value.is_a?(LMRest::Resource) || value.is_a?(Hash)
+    end
+
+    def resource_id(value)
+      case value
+      when LMRest::Resource
+        value.id if value.respond_to?(:id)
+      when Hash
+        value[:id] || value['id']
+      else
+        value
+      end
+    end
+
+    def resource_to_hash(value)
+      value.is_a?(LMRest::Resource) ? value.to_h : value
+    end
+
+    def data_for_signature(data, content_type)
+      return '' if data.nil? || (data.respond_to?(:empty?) && data.empty?)
+      return '' if multipart_form?(content_type)
+      return data if data.is_a?(String)
+
+      data.to_json.to_s
+    end
+
+    def serialize_payload(payload, content_type)
+      return nil if payload.nil?
+      return payload if multipart_form?(content_type)
+      return payload if payload.is_a?(String)
+
+      payload.to_json
+    end
+
+    def multipart_form?(content_type)
+      content_type.to_s.include?('multipart/form-data')
+    end
+
+    def website_interval_minutes(site)
+      interval_attrs = %i[checkInterval interval pollingInterval testInterval]
+      interval_attrs.each do |attr|
+        next unless site.respond_to?(attr)
+        value = site.send(attr)
+        return value.to_f if value
+      end
+      nil
+    end
+
+    def website_location_count(site)
+      location_attrs = %i[checkpoints checkpointIds checkpointId locations locationIds]
+      location_attrs.each do |attr|
+        next unless site.respond_to?(attr)
+        value = site.send(attr)
+        count = count_locations(value)
+        return count unless count.nil?
+      end
+      0
+    end
+
+    def count_locations(value)
+      case value
+      when Array
+        value.compact.length
+      when String
+        value.split(",").map(&:strip).reject(&:empty?).length
+      when Numeric
+        1
+      else
+        nil
+      end
+    end
   end
 end