nexus_cli 0.7.3 → 0.8.0

data/lib/nexus_cli/nexus_pro_remote.rb

@@ -1,113 +1,110 @@
-require 'restclient'
+require 'httpclient'
 require 'nokogiri'
-require 'tempfile'
 require 'yaml'
 
 module NexusCli
   class ProRemote < OSSRemote
-
-    def get_artifact_custom_info(artifact)
-      return N3Metadata::n3_to_xml(get_artifact_custom_info_n3(artifact))
-    end
-
-    def get_artifact_custom_info_n3(artifact)
+    # Gets the custom metadata for an artifact
+    # @param [String] artifact The GAVE string of the artifact
+    # @result [String] The resulting custom metadata xml from the get operation
+    def get_artifact_custom_info_raw(artifact)
       group_id, artifact_id, version, extension = parse_artifact_string(artifact)
-      get_string = N3Metadata::generate_n3_path(group_id, artifact_id, version, extension, configuration['repository'])
-      begin
-        n3 = nexus[get_string].get
-        if !n3.match(/<urn:maven#deleted>/).nil?
-          raise ArtifactNotFoundException
+      encoded_string = N3Metadata::create_base64_subject(group_id, artifact_id, version, extension)
+      response = nexus.get(nexus_url("service/local/index/custom_metadata/#{configuration['repository']}/#{encoded_string}"))
+      case response.status
+      when 200
+        if N3Metadata::missing_custom_metadata?(response.content)
+          raise N3NotFoundException
         else
-          return n3
+          return response.content
         end
-      rescue RestClient::ResourceNotFound => e
+      when 404
         raise ArtifactNotFoundException
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
-    def update_artifact_custom_info(artifact, *params)
-      group_id, artifact_id, version, extension = parse_artifact_string(artifact)
-      n3_user_urns = { "n3_header" => N3Metadata::generate_n3_header(group_id, artifact_id, version, extension) }.merge(N3Metadata::generate_n3_urns_from_hash(parse_update_params(*params)))
-
-      n3_temp = Tempfile.new("nexus_n3")
-      begin
-        n3_temp.write(N3Metadata::parse_n3_hash(n3_user_urns))
-        n3_temp.close
-        update_artifact_custom_info_n3(artifact, n3_temp.path)
-      ensure
-        n3_temp.close
-        n3_temp.unlink
-      end
+    # Gets the custom metadata for an artifact in a simplified XML format
+    # @param [String] artifact The GAVE string of the artifact
+    # @result [String] The resulting custom metadata xml from the get operation
+    def get_artifact_custom_info(artifact)
+      N3Metadata::convert_result_to_simple_xml(get_artifact_custom_info_raw(artifact))
     end
 
-    def update_artifact_custom_info_n3(artifact, file)
-      # Check if artifact exists before posting custom metadata.
-      get_artifact_info(artifact)
-      # Update the custom metadata using the n3 file.
-      group_id, artifact_id, version, extension = parse_artifact_string(artifact)
-      post_string = N3Metadata::generate_n3_path(group_id, artifact_id, version, extension, configuration['repository'])
+    # Updates custom metadata for an artifact
+    # @param [String] artifact The GAVE string of the artifact
+    # @param [Array] *params The array of key:value strings
+    # @result [Integer] The resulting exit code of the operation
+    def update_artifact_custom_info(artifact, *params)
+      target_n3 = parse_custom_metadata_update_params(*params)
 
       # Get all the urn:nexus/user# keys and consolidate.
       # Read in nexus n3 file. If this is a newly-added artifact, there will be no n3 file so escape the exception.
       begin
-        nexus_n3 = get_artifact_custom_info_n3(artifact)
-      rescue ArtifactNotFoundException
-        nexus_n3 = ""
+        nexus_n3 = N3Metadata::convert_result_to_hash(get_artifact_custom_info_raw(artifact))
+      rescue N3NotFoundException
+        nexus_n3 = {}
       end
 
-      # Read in local n3 file.
-      local_n3 = File.open(file).read
-
-      n3_user_urns = { "n3_header" => N3Metadata::generate_n3_header(group_id, artifact_id, version, extension) }
-      # Get the nexus keys.
-      n3_user_urns = N3Metadata::generate_n3_urns_from_n3(nexus_n3, n3_user_urns)
-      # Get the local keys and update the nexus keys.
-      n3_user_urns = N3Metadata::generate_n3_urns_from_n3(local_n3, n3_user_urns)
-      n3_temp = Tempfile.new("nexus_n3")
-      begin
-        n3_temp.write(N3Metadata::parse_n3_hash(n3_user_urns))
-        n3_temp.close
-        nexus[post_string].put({:file => File.new(n3_temp.path)})
-      ensure
-        n3_temp.close
-        n3_temp.unlink
+      group_id, artifact_id, version, extension = parse_artifact_string(artifact)
+      encoded_string = N3Metadata::create_base64_subject(group_id, artifact_id, version, extension)
+      response = nexus.post(nexus_url("service/local/index/custom_metadata/#{configuration['repository']}/#{encoded_string}"), :body => create_custom_metadata_update_json(nexus_n3, target_n3), :header => DEFAULT_CONTENT_TYPE_HEADER)
+      case response.code
+      when 201
+        return true
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
+    # Clears all custom metadata from an artifact
+    # @param [String] The GAVE string of the artifact
+    # @result [Integer] The resulting exit code of the operation
     def clear_artifact_custom_info(artifact)
-      get_artifact_info(artifact)
+      get_artifact_custom_info(artifact) # Check that artifact has custom metadata
       group_id, artifact_id, version, extension = parse_artifact_string(artifact)
-      post_string = N3Metadata::generate_n3_path(group_id, artifact_id, version, extension, configuration['repository'])
-      n3_user_urns = { "n3_header" => N3Metadata::generate_n3_header(group_id, artifact_id, version, extension) }
-      n3_temp = Tempfile.new("nexus_n3")
-      begin
-        n3_temp.write(N3Metadata::parse_n3_hash(n3_user_urns))
-        n3_temp.close
-        nexus[post_string].put({:file => File.new(n3_temp.path)})
-      ensure
-        n3_temp.close
-        n3_temp.unlink
+      encoded_string = N3Metadata::create_base64_subject(group_id, artifact_id, version, extension)
+      response = nexus.post(nexus_url("service/local/index/custom_metadata/#{configuration['repository']}/#{encoded_string}"), :body => create_custom_metadata_clear_json, :header => DEFAULT_CONTENT_TYPE_HEADER)
+      case response.status
+      when 201
+        return true
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
-    def search_artifacts(*params)
-      docs = Array.new
-      parse_search_params(*params).each do |param|
-        begin
-          nexus['service/local/search/m2/freeform'].get(:params => {:p => param[0], :t => param[1], :v => param[2]}) do |response|
-            raise BadSearchRequestException if response.code == 400
-            docs.push(Nokogiri::XML(response.body).xpath("/search-results/data"))
-          end
-        rescue RestClient::ResourceNotFound => e
+    # Searches for artifacts using custom metadata
+    # @param [Array] *params The array of key:type:value strings
+    # @result [String] The resulting xml from the search
+    def search_artifacts_custom(*params)
+      nodesets = Array.new
+      parse_custom_metadata_search_params(*params).each do |param|
+        response = nexus.get(nexus_url("service/local/search/m2/freeform"), :query => {:p => param[0], :t => param[1], :v => param[2]})
+        case response.status
+        when 200
+          nodesets.push(Nokogiri::XML(response.body).xpath("/search-results/data"))
+        when 400
+          raise BadSearchRequestException
+        when 404
           raise ArtifactNotFoundException
+        else
+          raise UnexpectedStatusCodeException.new(response.status)
         end
       end
-      result = docs.inject(docs.first) {|memo,doc| get_common_artifact_set(memo, doc)}
+      # Perform array intersection across all NodeSets for the final common set.
+      result = nodesets.inject(nodesets.first) {|memo, nodeset| get_common_artifact_set(memo, nodeset)}
       return result.nil? ? "" : result.to_xml(:indent => 4)
     end
 
     def get_pub_sub(repository_id)
-      nexus["service/local/smartproxy/pub-sub/#{repository_id}"].get
+      response = nexus.get(nexus_url("service/local/smartproxy/pub-sub/#{repository_id}"))
+      case response.status
+      when 200
+        return response.content
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
+      end
     end
 
     def enable_artifact_publish(repository_id)
@@ -123,17 +120,15 @@ module NexusCli
     end
 
     def artifact_publish(repository_id, params)
-      nexus["service/local/smartproxy/pub-sub/#{repository_id}"].put(create_pub_sub_json(params), :content_type => "application/json") do |response|
-        case response.code
-        when 200
-          return true
-        else
-          raise UnexpectedStatusCodeException.new(response.code)
-        end
+      response = nexus.put(nexus_url("service/local/smartproxy/pub-sub/#{repository_id}"), :body => create_pub_sub_json(params), :header => DEFAULT_CONTENT_TYPE_HEADER)
+      case response.status
+      when 200
+        return true
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
-
     def enable_artifact_subscribe(repository_id)
       raise NotProxyRepositoryException.new(repository_id) unless Nokogiri::XML(get_repository_info(repository_id)).xpath("/repository/data/repoType").first.content == "proxy"
 
@@ -151,13 +146,12 @@ module NexusCli
     end
 
     def artifact_subscribe(repository_id, params)
-      nexus["service/local/smartproxy/pub-sub/#{repository_id}"].put(create_pub_sub_json(params), :content_type => "application/json") do |response|
-        case response.code
-        when 200
-          return true
-        else
-          raise UnexpectedStatusCodeException.new(response.code)
-        end
+      response = nexus.put(nexus_url("service/local/smartproxy/pub-sub/#{repository_id}"), :body => create_pub_sub_json(params), :header => DEFAULT_CONTENT_TYPE_HEADER)
+      case response.status
+      when 200
+        return true
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
@@ -174,154 +168,177 @@ module NexusCli
     end
 
     def smart_proxy(params)
-      nexus["service/local/smartproxy/settings"].put(create_smart_proxy_settings_json(params), :content_type => "application/json") do |response|
-        case response.code
-        when 200
-          return true
-        else
-          raise UnexpectedStatusCodeException.new(response.code)
-        end
+      response = nexus.put(nexus_url("service/local/smartproxy/settings"), :body => create_smart_proxy_settings_json(params), :header => DEFAULT_CONTENT_TYPE_HEADER)
+      case response.status
+      when 200
+        return true
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
     def get_smart_proxy_settings
-      nexus["service/local/smartproxy/settings"].get(:accept => "application/json")
+      response = nexus.get(nexus_url("service/local/smartproxy/settings"), :header => DEFAULT_ACCEPT_HEADER)
+      case response.status
+      when 200
+        return response.content
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
+      end
     end
 
     def get_smart_proxy_key
-      nexus["service/local/smartproxy/settings"].get(:accept => "application/json")
+      response = nexus.get(nexus_url("service/local/smartproxy/settings"), :header => DEFAULT_ACCEPT_HEADER)
+      case response.status
+      when 200
+        return response.content
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
+      end
     end
 
     def add_trusted_key(certificate, description, path=true)
       params = {:description => description}
       params[:certificate] = path ? File.read(File.expand_path(certificate)) : certificate
-      nexus["service/local/smartproxy/trusted-keys"].post(create_add_trusted_key_json(params), :content_type => "application/json") do |response|
-        case response.code
-        when 201
-          return true
-        else
-          raise UnexpectedStatusCodeException.new(response.code)
-        end
+      response = nexus.post(nexus_url("service/local/smartproxy/trusted-keys"), :body => create_add_trusted_key_json(params), :header => DEFAULT_CONTENT_TYPE_HEADER)
+      case response.status
+      when 201
+        return true
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
     def delete_trusted_key(key_id)
-      nexus["service/local/smartproxy/trusted-keys/#{key_id}"].delete do |response|
-        case response.code
-        when 204
-          return true
-        else
-          raise UnexpectedStatusCodeException.new(response.code)
-        end
+      response = nexus.delete(nexus_url("service/local/smartproxy/trusted-keys/#{key_id}"))
+      case response.status
+      when 204
+        return true
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
     def get_trusted_keys
-      nexus["service/local/smartproxy/trusted-keys"].get(:accept => "application/json")
+      response = nexus.get(nexus_url("service/local/smartproxy/trusted-keys"), :header => DEFAULT_ACCEPT_HEADER)
+      case response.status
+      when 200
+        return response.content
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
+      end
     end
 
     def get_license_info
-      nexus["service/local/licensing"].get(:accept => "application/json")
+      response = nexus.get(nexus_url("service/local/licensing"), :header => DEFAULT_ACCEPT_HEADER)
+      case response.status
+      when 200
+        return response.content
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
+      end
     end
 
     def install_license(license_file)
       file = File.read(File.expand_path(license_file))
-      nexus["service/local/licensing/upload"].post(file, :content_type => "application/octet-stream") do |response|
-        case response.code
-        when 201
-          return true
-        when 403
-          raise LicenseInstallFailure
-        else
-          raise UnexpectedStatusCodeException.new(response.code)
-        end
+      response = nexus.post(nexus_url("service/local/licensing/upload"), :body => file, :header => {"Content-Type" => "application/octet-stream"})
+      case response.status
+      when 201
+        return true
+      when 403
+        raise LicenseInstallFailure
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
     def install_license_bytes(bytes)
-      nexus["service/local/licensing/upload"].post(bytes, :content_type => "application/octet-stream") do |response|
-        case response.code
-        when 201
-          return true
-        when 403
-          raise LicenseInstallFailure
-        else
-          raise UnexpectedStatusCodeException.new(response.code)
-        end
+      response = nexus.post(nexus_url("service/local/licensing/upload"), :body => bytes, :header => {"Content-Type" => "application/octet-stream"})
+      case response.status
+      when 201
+        return true
+      when 403
+        raise LicenseInstallFailure
+      else
+        raise UnexpectedStatusCodeException.new(response.status)
       end
     end
 
     private
 
-      def create_add_trusted_key_json(params)
-        JSON.dump(:data => params)
-      end
+    def create_add_trusted_key_json(params)
+      JSON.dump(:data => params)
+    end
 
-      def create_smart_proxy_settings_json(params)
-        JSON.dump(:data => params)
-      end
+    def create_smart_proxy_settings_json(params)
+      JSON.dump(:data => params)
+    end
 
-      def create_pub_sub_json(params)
-        JSON.dump(:data => params)
-      end
+    def create_pub_sub_json(params)
+      JSON.dump(:data => params)
+    end
 
-      def parse_update_params(*params)
-        begin
-          parsed_params = Hash.new
-          params.each do |param|
-            # The first colon separates key and value.
-            c1 = param.index(":")
-            key = param[0..(c1 - 1)]
-            value = param[(c1 + 1)..-1]
-            !c1.nil? && N3Metadata::valid_n3_key?(key) && N3Metadata::valid_n3_value?(value) ? parsed_params[key] = value : raise
-          end
-          return parsed_params
-        rescue
+    # Converts an array of parameters used to update custom metadata
+    # @param [Array] *params The array of key:value strings
+    # @return [Hash] The resulting hash of parsed key:value items
+    # @example
+    #   parse_custom_metadata_update_params(["cookie:oatmeal raisin"]) #=> {"cookie"=>"oatmeal raisin"}
+    def parse_custom_metadata_update_params(*params)
+      params.inject({}) do |parsed_params, param|
+        # param = key:value
+        metadata_key, metadata_value = param.split(":", 2)
+        if N3Metadata::valid_n3_key?(metadata_key) && N3Metadata::valid_n3_value?(metadata_value)
+          parsed_params[metadata_key] = metadata_value
+        else
           raise N3ParameterMalformedException
         end
+        parsed_params
       end
+    end
 
-      def parse_search_params(*params)
-        begin
-          parsed_params = Array.new
-          params.each do |param|
-            # The first two colons separate key, type, and value.
-            c1 = param.index(":")
-            c2 = param.index(":", (c1 + 1))
-            key = param[0..(c1 - 1)]
-            type = param[(c1 + 1)..(c2 - 1)]
-            value = param[(c2 + 1)..-1]
-            !c1.nil? && !c2.nil? && N3Metadata::valid_n3_key?(key) && N3Metadata::valid_n3_value?(value) && N3Metadata::valid_n3_search_type?(type) ? parsed_params.push([key, type, value]) : raise
-          end
-          return parsed_params
-        rescue
+    # Converts an array of parameters used to search by custom metadata
+    # @param [Array] *params The array of key:type:value strings
+    # @result [Array] The resulting array of parsed key:type:value items
+    # @example
+    #   parse_custom_metadata_search_params(["cookie:matches:oatmeal raisin"]) #=> #=> [["cookie","matches","oatmeal raisin"]]
+    def parse_custom_metadata_search_params(*params)
+      params.inject([]) do |parsed_params, param|
+        # param = key:type:value
+        metadata_key, search_type, metadata_value = param.split(":", 3)
+        if N3Metadata::valid_n3_key?(metadata_key) && N3Metadata::valid_n3_value?(metadata_value) && N3Metadata::valid_n3_search_type?(search_type)
+          parsed_params.push([metadata_key, search_type, metadata_value])
+        else
           raise SearchParameterMalformedException
         end
+        parsed_params
       end
+    end
 
-      # Expects the XML set with `data` as root.
-      def get_common_artifact_set(set1, set2)
-        intersection = get_artifact_array(set1) & get_artifact_array(set2)
-        return intersection.count > 0 ? Nokogiri::XML("<data>#{intersection.join}</data>").root : Nokogiri::XML("").root
-      end
+    def create_custom_metadata_update_json(source, target)
+      JSON.dump(:data => N3Metadata::create_metadata_hash(source, target))
+    end
 
-      # Collect <artifact>...</artifact> elements into an array.
-      # This will allow use of array intersection to find common artifacts in searches.
-      def get_artifact_array(set)
-        artifacts = Array.new
-        artifact = nil
-        set.to_s.split("\n").collect {|x| x.to_s.strip}.each do |piece|
-          if piece == "<artifact>"
-            artifact = piece
-          elsif piece == "</artifact>"
-            artifact += piece
-            artifacts.push(artifact)
-            artifact = nil
-          elsif !artifact.nil?
-            artifact += piece
-          end
-        end
-        return artifacts
+    def create_custom_metadata_clear_json
+      JSON.dump(:data => {})
+    end
+
+    # Gets the intersection of two artifact arrays, returning the common set
+    # @param [Array] set1, set2 The two Nokogiri::NodeSet objects to intersect
+    # @result [Nokogiri::NodeSet] The resulting object generated from the array intersect
+    def get_common_artifact_set(set1, set2)
+      intersection = get_artifact_array(set1) & get_artifact_array(set2)
+      return intersection.count > 0 ? Nokogiri::XML("<data>#{intersection.join}</data>").root : Nokogiri::XML("").root
+    end
+
+    # Collect <artifact> elements into an array
+    # @info This will allow use of array intersection to find common artifacts in searches
+    # @param [Nokogiri::NodeSet] set The object to be divided by <artifact> elements
+    # @result [Array] The result array of artifact elements
+    def get_artifact_array(set)
+      set.search("//artifact").inject([]) do |artifacts, artifact|
+        artifacts.push(artifact.to_s)
+        artifacts
       end
+    end
   end
 end