artifactory 1.1.0 → 1.2.0

data/lib/artifactory/configurable.rb

@@ -15,7 +15,12 @@ module Artifactory
           :endpoint,
           :username,
           :password,
-          :proxy,
+          :proxy_address,
+          :proxy_password,
+          :proxy_port,
+          :proxy_username,
+          :ssl_pem_file,
+          :ssl_verify,
           :user_agent,
         ]
       end

data/lib/artifactory/defaults.rb

@@ -55,12 +55,61 @@ module Artifactory
       end
 
       #
-      # The HTTP Proxy information as a string
+      # The HTTP Proxy server address as a string
       #
       # @return [String, nil]
       #
-      def proxy
-        ENV['ARTIFACTORY_PROXY']
+      def proxy_address
+        ENV['ARTIFACTORY_PROXY_ADDRESS']
+      end
+
+      #
+      # The HTTP Proxy user password as a string
+      #
+      # @return [String, nil]
+      #
+      def proxy_password
+        ENV['ARTIFACTORY_PROXY_PASSWORD']
+      end
+
+      #
+      # The HTTP Proxy server port as a string
+      #
+      # @return [String, nil]
+      #
+      def proxy_port
+        ENV['ARTIFACTORY_PROXY_PORT']
+      end
+
+      #
+      # The HTTP Proxy server username as a string
+      #
+      # @return [String, nil]
+      #
+      def proxy_username
+        ENV['ARTIFACTORY_PROXY_USERNAME']
+      end
+
+      #
+      # The path to a pem file on disk for use with a custom SSL verification
+      #
+      # @return [String, nil]
+      #
+      def ssl_pem_file
+        ENV['ARTIFACTORY_SSL_PEM_FILE']
+      end
+
+      #
+      # Verify SSL requests (default: true)
+      #
+      # @return [true, false]
+      #
+      def ssl_verify
+        if ENV['ARTIFACTORY_SSL_VERIFY'].nil?
+          true
+        else
+          %w[t y].include?(ENV['ARTIFACTORY_SSL_VERIFY'].downcase[0])
+        end
       end
     end
   end

data/lib/artifactory/errors.rb

@@ -1,22 +1,29 @@
 module Artifactory
   module Error
-    class ArtifactoryError < StandardError
-      def initialize(options = {})
-        class_name = self.class.to_s.split('::').last
-        error_key  = Util.underscore(class_name)
+    # Base class for all errors
+    class ArtifactoryError < StandardError; end
 
-        super I18n.t("artifactory.errors.#{error_key}", options)
+    # Class for all HTTP errors
+    class HTTPError < ArtifactoryError
+      attr_reader :code
+      attr_reader :message
+
+      def initialize(hash = {})
+        @code = hash['status'].to_i
+        @http = hash['message'].to_s
+
+        super "The Artifactory server responded with an HTTP Error "\
+              "#{@code}: `#{@http}'"
       end
     end
 
-    #
-    # Client errors
-    # ------------------------------
-    class ConnectionError < ArtifactoryError; end
-    class BadRequest < ConnectionError; end
-    class Forbidden < ConnectionError; end
-    class MethodNotAllowed < ConnectionError; end
-    class NotFound < ConnectionError; end
-    class Unauthorized < ConnectionError; end
+    # A general connection error with a more informative message
+    class ConnectionError < ArtifactoryError
+      def initialize(endpoint)
+        super "The Artifactory server at `#{endpoint}' is not currently " \
+              "accepting connections. Please ensure that the server is " \
+              "running an that your authentication information is correct."
+      end
+    end
   end
 end

data/lib/artifactory/resources/artifact.rb

@@ -198,7 +198,8 @@ module Artifactory
         format_repos!(params)
 
         client.get('/api/search/versions', params)['results']
-      rescue Error::NotFound
+      rescue Error::HTTPError => e
+        raise unless e.code == 404
         []
       end
 
@@ -252,73 +253,54 @@ module Artifactory
         params[:remote] = 1 if options[:remote]
 
         client.get('/api/search/latestVersion', params)
-      rescue Error::NotFound
+      rescue Error::HTTPError => e
+        raise unless e.code == 404
         nil
       end
 
       #
-      # Construct an artifact from the given URL.
-      #
-      # @example Create an artifact object from the given URL
-      #   Artifact.from_url('/path/to/some.deb') #=> #<Resource::Artifact>
-      #
-      # @param [Artifactory::Client] client
-      #   the client object to make the request with
-      # @param [String] url
-      #   the URL to find the artifact from
-      #
-      # @return [Resource::Artifact]
-      #
-      def from_url(url, options = {})
-        client = extract_client!(options)
-        from_hash(client.get(url), client: client)
-      end
-
-      #
-      # Create a instance from the given Hash. This method extracts the "safe"
-      # information from the hash and adds them to the instance.
-      #
-      # @example Create a new resource from a hash
-      #   Artifact.from_hash('downloadUri' => '...', 'size' => '...')
-      #
-      # @param [Artifactory::Client] client
-      #   the client object to make the request with
-      # @param [Hash] hash
-      #   the hash to create the instance from
-      #
-      # @return [Resource::Artifact]
+      # @see Artifactory::Resource::Base.from_hash
       #
       def from_hash(hash, options = {})
-        client = extract_client!(options)
-
-        new.tap do |instance|
-          instance.api_path      = hash['uri']
-          instance.client        = client
-          instance.created       = Time.parse(hash['created'])
-          instance.download_path = hash['downloadUri']
-          instance.last_modified = Time.parse(hash['lastModified'])
-          instance.last_updated  = Time.parse(hash['lastUpdated'])
-          instance.md5           = hash['checksums']['md5']
-          instance.mime_type     = hash['mimeType']
-          instance.repo          = hash['repo']
-          instance.sha1          = hash['checksums']['sha1']
-          instance.size          = hash['size'].to_i
+        super.tap do |instance|
+          instance.created       = Time.parse(instance.created) rescue nil
+          instance.last_modified = Time.parse(instance.last_modified) rescue nil
+          instance.last_updated  = Time.parse(instance.last_updated)  rescue nil
+          instance.size          = instance.size.to_i
         end
       end
     end
 
-    attribute :api_path, ->{ raise 'API path missing!' }
+    attribute :uri, ->{ raise 'API path missing!' }
+    attribute :checksums
     attribute :created
-    attribute :download_path, ->{ raise 'Download path missing!' }
+    attribute :download_uri, ->{ raise 'Download URI missing!' }
+    attribute :key
     attribute :last_modified
     attribute :last_updated
     attribute :local_path, ->{ raise 'Local destination missing!' }
     attribute :mime_type
-    attribute :md5
     attribute :repo
-    attribute :sha1
     attribute :size
 
+    #
+    # The SHA of this artifact.
+    #
+    # @return [String]
+    #
+    def sha1
+      checksums && checksums['sha1']
+    end
+
+    #
+    # The MD5 of this artifact.
+    #
+    # @return [String]
+    #
+    def md5
+      checksums && checksums['md5']
+    end
+
     #
     # @see Artifact#copy_or_move
     #
@@ -334,8 +316,8 @@ module Artifactory
     #   true if the object was deleted successfully, false otherwise
     #
     def delete
-      !!client.delete(download_path)
-    rescue Error::NotFound
+      !!client.delete(download_uri)
+    rescue Error::HTTPError
       false
     end
 
@@ -356,7 +338,7 @@ module Artifactory
     #   the list of properties
     #
     def properties
-      @properties ||= client.get(api_path, properties: nil)['properties']
+      @properties ||= client.get(uri, properties: nil)['properties']
     end
 
     #
@@ -402,18 +384,110 @@ module Artifactory
       FileUtils.mkdir_p(target) unless File.exists?(target)
 
       # Use the server artifact's filename if one wasn't given
-      filename = options[:filename] || File.basename(download_path)
+      filename = options[:filename] || File.basename(download_uri)
 
       # Construct the full path for the file
-      destination = File.join(targer, filename)
+      destination = File.join(target, filename)
 
-      File.open(File.join(destination, filename), 'wb') do |file|
-        file.write(_get(download_path))
+      File.open(destination, 'wb') do |file|
+        file.write(client.get(download_uri))
       end
 
       destination
     end
 
+    #
+    # Upload an artifact into the repository. If the first parameter is a File
+    # object, that file descriptor is passed to the uploader. If the first
+    # parameter is a string, it is assumed to be the path to a local file on
+    # disk. This method will automatically construct the File object from the
+    # given path.
+    #
+    # @see bit.ly/1dhJRMO Artifactory Matrix Properties
+    #
+    # @example Upload an artifact from a File instance
+    #   file = File.new('/local/path/to/file.deb')
+    #   artifact = Artifact.new
+    #   artifact.upload(file, 'libs-release-local', file.deb')
+    #
+    # @example Upload an artifact from a path
+    #   artifact.upload('/local/path/to/file.deb', 'libs-release-local', 'file.deb')
+    #
+    # @example Upload an artifact with matrix properties
+    #   artifact.upload('/local/path/to/file.deb', 'libs-release-local', file.deb', {
+    #     status: 'DEV',
+    #     rating: 5,
+    #     branch: 'master'
+    #   })
+    #
+    # @param [String] key
+    #   the key of the repository to which to upload the file
+    # @param [String, File] path_or_io
+    #   the file or path to the file to upload
+    # @param [String] path
+    #   the path where this resource will live in the remote artifactory
+    #   repository, relative to the repository key
+    # @param [Hash] headers
+    #   the list of headers to send with the request
+    # @param [Hash] properties
+    #   a list of matrix properties
+    #
+    # @return [Resource::Artifact]
+    #
+    def upload(key, path_or_io, path, properties = {}, headers = {})
+      file = if respond_to?(:read)
+               path_or_io
+             else
+               File.new(File.expand_path(path_or_io))
+             end
+
+      matrix   = to_matrix_properties(properties)
+      endpoint = File.join("#{url_safe(key)}#{matrix}", path)
+
+      response = client.put(endpoint, file, headers)
+      self.class.from_hash(response)
+    end
+
+    #
+    # Upload an artifact with the given SHA checksum. Consult the artifactory
+    # documentation for the possible responses when the checksums fail to
+    # match.
+    #
+    # @see Artifact#upload More syntax examples
+    #
+    # @example Upload an artifact with a checksum
+    #   artifact = Artifact.new
+    #   artifact.upload_with_checksum('/local/file', 'libs-release-local', /remote/path', 'ABCD1234')
+    #
+    # @param (see Artifact#upload)
+    # @param [String] checksum
+    #   the SHA1 checksum of the artifact to upload
+    #
+    def upload_with_checksum(key, path_or_io, path, checksum, properties = {})
+      upload(key, path_or_io, path, properties,
+        'X-Checksum-Deploy' => true,
+        'X-Checksum-Sha1'   => checksum,
+      )
+    end
+
+    #
+    # Upload an artifact with the given archive. Consult the artifactory
+    # documentation for the format of the archive to upload.
+    #
+    # @see Artifact#upload More syntax examples
+    #
+    # @example Upload an artifact with a checksum
+    #   artifact = Artifact.new('libs-release-local')
+    #   artifact.upload_from_archive('/local/archive', '/remote/path')#
+    #
+    # @param (see Repository#upload)
+    #
+    def upload_from_archive(key, path_or_io, path, properties = {})
+      upload(key, path_or_io, path, properties,
+        'X-Explode-Archive' => true,
+      )
+    end
+
     private
 
     #
@@ -426,7 +500,7 @@ module Artifactory
     # @return [String]
     #
     def relative_path
-      @relative_path ||= api_path.split('/api/storage', 2).last
+      @relative_path ||= uri.split('/api/storage', 2).last
     end
 
     #

data/lib/artifactory/resources/base.rb

@@ -27,7 +27,7 @@ module Artifactory
       def attribute(key, default = nil)
         key = key.to_sym unless key.is_a?(Symbol)
 
-        # Set the key on the top attributes, mostly for asthetic purposes
+        # Set this attribute in the top-level hash
         attributes[key] = nil
 
         define_method(key) do
@@ -52,6 +52,73 @@ module Artifactory
         end
       end
 
+      #
+      # The list of attributes defined by this class.
+      #
+      # @return [Array<Symbol>]
+      #
+      def attributes
+        @attributes ||= {}
+      end
+
+      #
+      # Determine if this class has a given attribute.
+      #
+      # @param [#to_sym] key
+      #   the key to check as an attribute
+      #
+      # @return [true, false]
+      #
+      def has_attribute?(key)
+        attributes.has_key?(key.to_sym)
+      end
+
+      #
+      # Construct a new object from the given URL.
+      #
+      # @param [String] url
+      #   the URL to find the user from
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [~Resource::Base]
+      #
+      def from_url(url, options = {})
+        client = extract_client!(options)
+        from_hash(client.get(url), client: client)
+      end
+
+      #
+      # Construct a new object from the hash.
+      #
+      # @param [Hash] hash
+      #   the hash to create the object with
+      # @param [Hash] options
+      #   the list options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [~Resource::Base]
+      #
+      def from_hash(hash, options = {})
+        instance = new
+        instance.client = extract_client!(options)
+
+        hash.inject(instance) do |instance, (key, value)|
+          method = :"#{Util.underscore(key)}="
+
+          if instance.respond_to?(method)
+            instance.send(method, value)
+          end
+
+          instance
+        end
+      end
+
       #
       # Get the client (connection) object from the given options. If the
       # +:client+ key is preset in the hash, it is assumed to contain the
@@ -103,10 +170,6 @@ module Artifactory
       def url_safe(value)
         URI.escape(value.to_s)
       end
-
-      def attributes
-        @attributes ||= {}
-      end
     end
 
     attribute :client, ->{ Artifactory.client }
@@ -159,6 +222,55 @@ module Artifactory
       self.class.url_safe(value)
     end
 
+    #
+    # The hash representation
+    #
+    # @example An example hash response
+    #   { 'key' => 'local-repo1', 'includesPattern' => '**/*' }
+    #
+    # @return [Hash]
+    #
+    def to_hash
+      attributes.inject({}) do |hash, (key, value)|
+        unless Resource::Base.has_attribute?(key)
+          hash[Util.camelize(key, true)] = value
+        end
+
+        hash
+      end
+    end
+
+    #
+    # The JSON representation of this object.
+    #
+    # @see Artifactory::Resource::Base#to_json
+    #
+    # @return [String]
+    #
+    def to_json
+      JSON.fast_generate(to_hash)
+    end
+
+    #
+    # Create URI-escaped string from matrix properties
+    #
+    # @see http://bit.ly/1qeVYQl
+    #
+    def to_matrix_properties(hash = {})
+      properties = hash.map do |k, v|
+        key   = URI.escape(k.to_s)
+        value = URI.escape(v.to_s)
+
+        "#{key}=#{value}"
+      end
+
+      if properties.empty?
+        nil
+      else
+        ";#{properties.join(';')}"
+      end
+    end
+
     # @private
     def to_s
       "#<#{short_classname}>"
@@ -167,7 +279,9 @@ module Artifactory
     # @private
     def inspect
       list = attributes.collect do |key, value|
-        "#{key}: #{value.inspect}" unless key == :client
+        unless Resource::Base.has_attribute?(key)
+          "#{key}: #{value.inspect}"
+        end
       end.compact
 
       "#<#{short_classname} #{list.join(', ')}>"