collins_client 0.2.7

data/lib/collins/api/admin.rb

@@ -0,0 +1,19 @@
+require 'uri'
+
+module Collins; module Api
+
+  module Admin
+
+    def repopulate_solr! wait_for_completion = true
+      parameters = {
+        :waitForCompletion => wait_for_completion
+      }
+      http_get("/api/admin/solr", parameters) do |response|
+        parse_response response, :expects => 200
+      end
+
+    end
+
+  end
+end; end
+

data/lib/collins/api/asset.rb

@@ -0,0 +1,184 @@
+require 'uri'
+
+module Collins; module Api
+
+  module Asset
+
+    def create! asset_or_tag, options = {}
+      asset = get_asset_or_tag asset_or_tag
+      parameters = {
+        :generate_ipmi => get_option(:generate_ipmi, options, false),
+        :status => get_option(:status, options, asset.status),
+        :type => get_option(:type, options, asset.type)
+      }
+      parameters = select_non_empty_parameters parameters
+      logger.debug("Creating asset #{asset.tag} with parameters #{parameters.inspect}")
+      http_put("/api/asset/#{asset.tag}", parameters) do |response|
+        parse_response response, :expects => 201, :as => :asset
+      end
+    end
+
+    def delete! asset_or_tag, options = {}
+      asset = get_asset_or_tag asset_or_tag
+      parameters = {
+        :reason => get_option(:reason, options, nil)
+      }
+      parameters = select_non_empty_parameters parameters
+      logger.debug("Deleting asset #{asset.tag} with parameters #{parameters.inspect}")
+      http_delete("/api/asset/#{asset.tag}", parameters, asset.location) do |response|
+        parse_response response, :expects => 200, :as => :status, :raise => strict?, :default => false
+      end
+    end
+
+    def exists? asset_or_tag, status = nil
+      begin
+        asset = get(asset_or_tag)
+        if asset && status && asset.status.downcase == status.downcase then
+          true
+        elsif asset && status.nil? then
+          true
+        else
+          false
+        end
+      rescue Collins::RequestError => e
+        if e.code.to_i == 404 then
+          false
+        else
+          # if strict? is true, should still return a boolean for exists?
+          logger.info("Exception getting asset: #{e.class} #{e}")
+          false
+        end
+      rescue Exception => e
+        if e.class.to_s == "WebMock::NetConnectNotAllowedError" then
+          raise e
+        end
+        # if strict? is true, should still return a boolean for exists?
+        logger.info("Exception getting asset: #{e.class} - #{e}")
+        false
+      end
+    end
+
+    def get asset_or_tag, options = {}
+      asset = get_asset_or_tag asset_or_tag
+      parameters = {
+        :location => get_option(:location, options, nil)
+      }
+      parameters = select_non_empty_parameters parameters
+      logger.debug("Getting asset #{asset.tag} with params #{parameters.inspect}")
+      http_get("/api/asset/#{asset.tag}", parameters, asset.location) do |response|
+        parse_response response, :as => :asset, :expects => 200, :raise => strict?, :default => false
+      end
+    end
+
+    # Find assets matching the specified criteria
+    #
+    # In general the options hash corresponds to asset key/value pairs. Reserved keys in the selector
+    # are treated with care. These keys are in {Collins::Asset::Find::DATE\_PARAMS} and in
+    # {Collins::Asset::Find::GENERAL\_PARAMS}. All other keys are assumed to be asset attributes.
+    # @param [Hash] options Query options
+    # @return [Array<Collins::Asset>] An array of assets matching the query
+    # @raise [UnexpectedResponseError] If the HTTP response code is not a 200
+    def find options = {}
+      solrquery = options.delete(:query)
+      if solrquery != nil then
+        return search solrquery, options[:size], options.sort
+      end
+      use_api_version "1.1"
+      query = asset_hash_to_find_query options
+      params = query.to_a.map do |param|
+        key, val = param
+        if val.is_a?(Array) then
+          val.map{|v| "#{key}=#{asset_escape_attribute(v)}"}.join("&")
+        else
+          "#{key}=#{asset_escape_attribute(val)}"
+        end
+      end.reject{|s| s.empty?}
+      logger.debug("Finding assets using params #{params.inspect}")
+      http_get("/api/assets", params) do |response|
+        parse_response response, :expects => 200, :as => :paginated do |json|
+          json.map { |j| Collins::Asset.from_json(j) }
+        end
+      end
+    end
+
+    def search query, size = 50, sort = "ASC", sort_field = "tag"
+      use_api_version "1.2"
+      if query.start_with? "\"" and query.end_with? "\"" then
+        query = query[1..-2]
+      end
+      params = {
+        :query => query,
+        :size => size,
+        :sort => sort,
+        :sort_field => sort_field
+      }
+      logger.debug("perform asset search using query #{query}")
+      http_get("/api/assets",params) do |response|
+        parse_response response, :expects => 200, :as => :paginated do |json|
+          json.map { |j| Collins::Asset.from_json(j) }
+        end
+      end
+    end
+
+    def find_similar asset_or_tag, size = 50, sort = "ASC", sort_type = "distance", only_unallocated = true
+      asset = get_asset_or_tag asset_or_tag
+      params = {
+        :size => size,
+        :sort => sort,
+        :sortType => sort_type,
+        :onlyUnallocated => only_unallocated
+      }
+      logger.debug("Finding similar assets for #{asset.tag}")
+      http_get("/api/asset/#{asset.tag}/similar", params) do |response|
+        parse_response response, :expects => 200, :as => :paginated do |json|
+          json.map { |j| Collins::Asset.from_json(j) }
+        end
+      end
+    end
+
+    private
+    def asset_escape_attribute value
+      URI.escape(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def asset_hash_to_find_query opts = {}
+      options = opts.clone
+      hash = {:attribute => []}
+      okeys = options.keys
+      Collins::Asset::Find::DATE_PARAMS.each do |query_key|
+        okeys.each do |user_key|
+          if query_key.to_s.downcase == user_key.to_s.downcase then
+            hash[query_key.to_sym] = Collins::Asset.format_date_string(options.delete(user_key))
+          end
+        end
+      end
+      Collins::Asset::Find::GENERAL_PARAMS.each do |query_key|
+        okeys.each do |user_key|
+          if query_key.to_s.downcase == user_key.to_s.downcase then
+            hash[query_key.to_sym] = options.delete(user_key)
+          end
+        end
+      end
+      options.each do |k,v|
+        hash[:attribute] << "#{k};#{regex_to_string(v)}"
+      end
+      hash
+    end
+
+    def regex_to_string value
+      if is_regex? value then
+        rewrite_regex value
+      else
+        value
+      end
+    end
+    def is_regex? value
+      value.is_a?(Regexp)
+    end
+    def rewrite_regex value
+      value.inspect[1..-2] # turn /lkasd/ into lkasd
+    end
+
+  end
+
+end; end

data/lib/collins/api/asset_state.rb

@@ -0,0 +1,85 @@
+module Collins; module Api
+
+  module AssetState
+    def state_test; @state_test end
+    def state_test= v; @state_test = v end
+    module_function :state_test, :state_test=
+
+    def state_create! name, label, description, status = nil
+      name = validate_state_name name
+      parameters = {
+        :label => label,
+        :description => description,
+        :status => status
+      }
+      if not ::Collins::Api::AssetState.state_test then
+        parameters = select_non_empty_parameters parameters
+      end
+      logger.debug("Creating state with name #{name}")
+      http_put("/api/state/#{name}", parameters) do |r|
+        parse_response r, :expects => 201, :as => :status, :raise => strict?, :default => false
+      end
+    end
+    def state_delete! name
+      name = validate_state_name name
+      logger.debug("Deleting state with name #{name}")
+      http_delete("/api/state/#{name}") do |r|
+        parse_response r, :expects => 202, :as => :data, :raise => strict?, :default => 0 do |js|
+          js["DELETED"].to_s.to_i
+        end
+      end
+    end
+    def state_update! name, options = {}
+      name = validate_state_name name
+      parameters = {
+        :label => options[:label],
+        :description => options[:description],
+        :name => options[:name],
+        :status => options[:status]
+      }
+      if not ::Collins::Api::AssetState.state_test then
+        parameters = select_non_empty_parameters parameters
+      end
+      logger.debug("Updating state with name #{name} params #{parameters}")
+      http_post("/api/state/#{name}", parameters) do |r|
+        parse_response r, :expects => 200, :as => :status, :raise => strict?, :default => false
+      end
+    end
+    def state_get name
+      name = validate_state_name name
+      logger.debug("Fetching state with name #{name}")
+      http_get("/api/state/#{name}") do |r|
+        empty = ::Collins::AssetState.new({})
+        parse_response r, :expects => 200, :as => :data, :default => empty, :raise => false do |js|
+          ::Collins::AssetState.from_json(js)
+        end
+      end
+    end
+    def state_get_all
+      http_get("/api/states") do |r|
+        parse_response r, :expects => 200, :as => :data, :default => [], :raise => false do |js|
+          js.map do |state|
+            ::Collins::AssetState.from_json(state)
+          end
+        end
+      end
+    end
+
+    private
+    def validate_state_name name
+      if ::Collins::Api::AssetState.state_test then
+        return name
+      end
+      name_opt = ::Collins::Option(name).map {|x| x.to_s.strip}.filter_not {|x| x.empty?}.filter {|x|
+        x.size > 1 && x.size <= 32
+      }
+      if name_opt.empty? then
+        raise ::Collins::ExpectationFailedError.new("name must be between 2 and 32 characters")
+      else
+        name_opt.get
+      end
+    end
+
+  end # end module AssetState
+
+end; end

data/lib/collins/api/attributes.rb

@@ -0,0 +1,76 @@
+module Collins; module Api
+
+  module Attributes
+    def delete_attribute! asset_or_tag, attribute, group_id = nil
+      asset = get_asset_or_tag asset_or_tag
+      parameters = {
+        :groupId => group_id
+      }
+      parameters = select_non_empty_parameters parameters
+      logger.debug("Deleting attribute #{attribute} on #{asset.tag} with params #{parameters.inspect}")
+      http_delete("/api/asset/#{asset.tag}/attribute/#{attribute}", parameters, asset.location) do |response|
+        parse_response response, :expects => 202, :as => :status, :raise => strict?, :default => false
+      end
+    end
+    def set_attribute! asset_or_tag, key, value, group_id = nil
+      asset = get_asset_or_tag asset_or_tag
+      parameters = {
+        :attribute => "#{key};#{value}",
+        :groupId => group_id
+      }
+      parameters = select_non_empty_parameters parameters
+      logger.debug("Setting attribute #{key} to #{value} on #{asset.tag}")
+      http_post("/api/asset/#{asset.tag}", parameters, asset.location) do |response|
+        parse_response response, :expects => 200, :as => :status, :raise => strict?, :default => false
+      end
+    end
+
+    # Set the status of an asset
+    # @overload set_status!(asset_or_tag, status, reason = 'Set via API', state = nil)
+    #   Set the status, reason and optionally state of asset
+    #   @param [String,Collins::Asset] asset_or_tag The asset or tag
+    #   @param [String] status the status of the asset
+    #   @param [String] reason the reason for the change
+    #   @param [String] state the asset state
+    # @overload set_status!(asset_or_tag, hash)
+    #   Set the status, reason, and optionally state of asset
+    #   @param [String,Collins::Asset] asset_or_tag The asset or tag
+    #   @param [Hash] hash the options to set
+    #   @option hash [String] :status The asset status
+    #   @option hash [String] :reason The reason for the change
+    #   @option hash [String] :state The asset state
+    # @return Boolean
+    def set_status! asset_or_tag, *varargs
+      status = state = nil
+      reason = 'Set via ruby client'
+      asset = get_asset_or_tag asset_or_tag
+      if varargs.size == 0 then
+        raise ::Collins::ExpectationFailedError.new("set_status! requires a status")
+      elsif varargs.size == 1 and varargs[0].is_a?(Hash) then
+        hash = symbolize_hash(varargs[0], :downcase => true)
+        status = hash[:status]
+        reason = hash.fetch(:reason, reason)
+        state = hash[:state]
+      elsif varargs.size == 1 and (varargs[0].is_a?(String) or varargs[0].is_a?(Symbol)) then
+        status = varargs[0].to_s
+      elsif varargs.size > 1 then
+        status = varargs[0]
+        reason = varargs[1]
+        state = varargs[2] if varargs.size > 2
+      else
+        raise ::Collins::ExpectationFailedError.new("set_status! called with invalid parameters")
+      end
+      parameters = {
+        :status => status,
+        :reason => reason,
+        :state => state
+      }
+      parameters = select_non_empty_parameters parameters
+      logger.debug("Setting status to #{status} on #{asset.tag}")
+      http_post("/api/asset/#{asset.tag}/status", parameters, asset.location) do |response|
+        parse_response response, :expects => 200, :as => :status, :raise => strict?, :default => false
+      end
+    end
+  end # module Attributes
+
+end; end

data/lib/collins/api/ip_address.rb

@@ -0,0 +1,87 @@
+require 'collins/address'
+
+module Collins; module Api
+
+  module IpAddress
+    def ipaddress_allocate! asset_or_tag, address_pool, count = 1
+      asset = get_asset_or_tag asset_or_tag
+      logger.debug("Allocating #{count} addresses for #{asset.tag} in pool #{address_pool}")
+      parameters = {
+        :count => count,
+        :pool => address_pool
+      }
+      http_put("/api/asset/#{asset.tag}/address", parameters, asset.location) do |response|
+        parse_response response, :expects => 201, :default => [] do |json|
+          Collins::Address.from_json(json["data"]["ADDRESSES"])
+        end
+      end
+    end
+
+    def ipaddress_update! asset_or_tag, old_address = nil, options = {}
+      asset = get_asset_or_tag asset_or_tag
+      logger.debug("Updating IP address for #{asset.tag}")
+      parameters = {
+        :old_address => old_address,
+        :address => get_option(:address, options, nil),
+        :gateway => get_option(:gateway, options, nil),
+        :netmask => get_option(:netmask, options, nil),
+        :pool => get_option(:pool, options, nil)
+      }
+      parameters = select_non_empty_parameters parameters
+      http_post("/api/asset/#{asset.tag}/address", parameters, asset.location) do |response|
+        parse_response response, :expects => [200,201], :default => false, :raise => strict?
+      end
+    end
+
+    def ipaddress_delete! asset_or_tag, pool = nil
+      asset = get_asset_or_tag asset_or_tag
+      logger.debug("Deleting addresses for asset #{asset.tag} in pool #{pool}")
+      parameters = {
+        :pool => pool
+      }
+      parameters = select_non_empty_parameters parameters
+      http_delete("/api/asset/#{asset.tag}/addresses", parameters, asset.location) do |response|
+        parse_response response, :expects => 200, :default => false, :raise => strict? do |json|
+          json["data"]["DELETED"].to_s.to_i
+        end
+      end
+    end
+
+    def ipaddress_pools show_all = true
+      logger.debug("Finding IP address pools")
+      http_get("/api/address/pools", {:all => show_all}) do |response|
+        parse_response response, :expects => 200, :default => [], :raise => strict? do |json|
+          json["data"]["POOLS"]
+        end
+      end
+    end
+
+    def addresses_for_asset asset_or_tag
+      asset = get_asset_or_tag asset_or_tag
+      logger.debug("Getting IP addresses for asset #{asset.tag}")
+      http_get("/api/asset/#{asset.tag}/addresses", {}, asset.location) do |response|
+        parse_response response, :expects => 200, :default => [], :raise => strict? do |json|
+          Collins::Address.from_json(json["data"]["ADDRESSES"])
+        end
+      end
+    end
+
+    def asset_at_address address
+      logger.debug("Finding asset at address #{address}")
+      http_get("/api/asset/with/address/#{address}") do |response|
+        parse_response response, :expects => 200, :default => nil, :raise => strict?, :as => :bare_asset
+      end
+    end
+
+    def assets_in_pool pool
+      logger.debug("Finding assets in pool #{pool}")
+      http_get("/api/assets/with/addresses/in/#{pool}") do |response|
+        parse_response response, :expects => 200, :default => [], :raise => strict? do |json|
+          json["data"]["ASSETS"].map{|j| Collins::Asset.from_json(j, true)}
+        end
+      end
+    end
+
+  end # module IpAddress
+
+end; end