artifactory 0.0.1 → 1.0.0

data/lib/artifactory/resources/base.rb

@@ -0,0 +1,145 @@
+module Artifactory
+  class Resource::Base
+    class << self
+      #
+      # @macro attribute
+      #   @method $1
+      #     Return this object's +$1+
+      #
+      #     @return [Object]
+      #
+      #
+      #   @method $1=(value)
+      #     Set this object's +$1+
+      #
+      #     @param [Object] value
+      #       the value to set for +$1+
+      #     @param [Object] default
+      #       the default value for this attribute
+      #
+      #   @method $1?
+      #     Determines if the +$1+ value exists and is truthy
+      #
+      #     @return [Boolean]
+      #
+      def attribute(key, default = nil)
+        define_method(key) do
+          value = instance_variable_get("@#{key}")
+          return value unless value.nil?
+
+          if default.nil?
+            value
+          elsif default.is_a?(Proc)
+            default.call
+          else
+            default
+          end
+        end
+
+        define_method("#{key}?") do
+          !!send(key)
+        end
+
+        define_method("#{key}=") do |value|
+          instance_variable_set("@#{key}", value)
+        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
+      # connection object to use for the request. If the +:client+ key is not
+      # present, the default {Artifactory.client} is used.
+      #
+      # Warning, the value of {Artifactory.client} is **not** threadsafe! If
+      # multiple threads or processes are modifying the connection information,
+      # the same request _could_ use a different client object. If you use the
+      # {Artifactory::Client} proxy methods, this is handled for you.
+      #
+      # Warning, this method will **remove** the +:client+ key from the hash if
+      # it exists.
+      #
+      # @param [Hash] options
+      #   the list of options passed to the method
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to use for requests
+      #
+      def extract_client!(options)
+        options.delete(:client) || Artifactory.client
+      end
+
+      #
+      # Format the repos list from the given options. This method will modify
+      # the given Hash parameter!
+      #
+      # Warning, this method will modify the given hash if it exists.
+      #
+      # @param [Hash] options
+      #   the list of options to extract the repos from
+      #
+      def format_repos!(options)
+        return options if options[:repos].nil? || options[:repos].empty?
+        options[:repos] = Array(options[:repos]).compact.join(',')
+        options
+      end
+
+      #
+      # Generate a URL-safe string from the given value.
+      #
+      # @param [#to_s] value
+      #   the value to sanitize
+      #
+      # @return [String]
+      #   the URL-safe version of the string
+      #
+      def url_safe(value)
+        URI.escape(value.to_s)
+      end
+    end
+
+    attribute :client, ->{ Artifactory.client }
+
+    #
+    # Create a new instance
+    #
+    def initialize(attributes = {})
+      attributes.each { |key, value| send(:"#{key}=", value) }
+    end
+
+    # @see {Resource::Base.extract_client!}
+    def extract_client!(options)
+      self.class.extract_client!(options)
+    end
+
+    # @see {Resource::Base.format_repos!}
+    def format_repos!(options)
+      self.class.format_repos!(options)
+    end
+
+    # @see {Resource::Base.url_safe}
+    def url_safe(value)
+      self.class.url_safe(value)
+    end
+
+    def to_s
+      "#<#{self.class.name}>"
+    end
+
+    def inspect
+      map = instance_variables.map do |k|
+        unless k == :@client
+          value = instance_variable_get(k)
+
+          if !value.nil?
+            "#{k.to_s.gsub(/^@/, '')}: #{value.inspect}"
+          else
+            nil
+          end
+        end
+      end.compact
+
+      "#<#{self.class.name} #{map.join(', ')}>"
+    end
+  end
+end

data/lib/artifactory/resources/build.rb

@@ -0,0 +1,27 @@
+module Artifactory
+  class Resource::Build < Resource::Base
+    class << self
+      #
+      # Search for all builds in the system.
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [Array<Resource::Build>]
+      #   the list of builds
+      #
+      def all(options = {})
+        client = extract_client!(options)
+        client.get('/api/build')
+      rescue Error::NotFound
+        # Artifactory returns a 404 instead of an empty list when there are no
+        # builds. Whoever decided that was a good idea clearly doesn't
+        # understand the point of REST interfaces...
+        []
+      end
+    end
+  end
+end

data/lib/artifactory/resources/plugin.rb

@@ -0,0 +1,22 @@
+module Artifactory
+  class Resource::Plugin < Resource::Base
+    class << self
+      #
+      # Get a list of all plugins in the system.
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [Array<Resource::Plugin>]
+      #   the list of builds
+      #
+      def all(options = {})
+        client = extract_client!(options)
+        client.get('/api/plugins')
+      end
+    end
+  end
+end

data/lib/artifactory/resources/repository.rb

@@ -0,0 +1,251 @@
+module Artifactory
+  class Resource::Repository < Resource::Base
+    class << self
+      #
+      # Get a list of all repositories in the system.
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [Array<Resource::Repository>]
+      #   the list of builds
+      #
+      def all(options = {})
+        client = extract_client!(options)
+        client.get('/api/repositories').map do |hash|
+          find(name: hash['key'], client: client)
+        end.compact
+      end
+
+      #
+      # Find (fetch) a repository by name.
+      #
+      # @example Find a respository by named key
+      #   Repository.find(name: 'libs-release-local') #=> #<Resource::Artifact>
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [String] :name
+      #   the name of the repository to find
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [Resource::Repository, nil]
+      #   an instance of the repository that matches the given name, or +nil+
+      #   if one does not exist
+      #
+      def find(options = {})
+        client = extract_client!(options)
+        name   = options[:name]
+
+        result = client.get("/api/repositories/#{url_safe(name)}")
+        from_hash(result, client: client)
+      rescue Error::NotFound
+        nil
+      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
+      #   Repository.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::Repository]
+      #
+      def from_hash(hash, options = {})
+        client = extract_client!(options)
+
+        new.tap do |instance|
+          instance.blacked_out               = hash['blackedOut']
+          instance.description               = hash['description']
+          instance.checksum_policy           = hash['checksumPolicyType']
+          instance.excludes_pattern          = hash['excludesPattern']
+          instance.handle_releases           = hash['handleReleases']
+          instance.handle_snapshots          = hash['handleSnapshots']
+          instance.includes_pattern          = hash['includesPattern']
+          instance.key                       = hash['key']
+          instance.maximum_unique_snapshots  = hash['maxUniqueSnapshots']
+          instance.notes                     = hash['notes']
+          instance.property_sets             = hash['propertySets']
+          instance.snapshot_version_behavior = hash['snapshotVersionBehavior']
+          instance.suppress_pom_checks       = hash['suppressPomConsistencyChecks']
+          instance.type                      = hash['rclass']
+        end
+      end
+    end
+
+    attribute :blacked_out, false
+    attribute :description
+    attribute :checksum_policy, 'client-checksums'
+    attribute :excludes_pattern, ''
+    attribute :handle_releases, true
+    attribute :handle_snapshots, true
+    attribute :includes_pattern, '**/*'
+    attribute :key, ->{ raise 'Key is missing!' }
+    attribute :maximum_unique_snapshots, 0
+    attribute :notes
+    attribute :property_sets, []
+    attribute :snapshot_version_behavior, 'non-unique'
+    attribute :suppress_pom_checks, false
+    attribute :type
+
+    #
+    # 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')
+    #   repo = Repository.new('libs-release-local')
+    #   repo.upload(file, 'file.deb')
+    #
+    # @example Upload an artifact from a path
+    #   repo = Repository.new('libs-release-local')
+    #   repo.upload('/local/path/to/file.deb', 'file.deb')
+    #
+    # @example Upload an artifact with matrix properties
+    #   repo = Repository.new('libs-release-local')
+    #   repo.upload('/local/path/to/file.deb', 'file.deb', {
+    #     status: 'DEV',
+    #     rating: 5,
+    #     branch: 'master'
+    #   })
+    #
+    # @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 current repo
+    # @param [Hash] headers
+    #   the list of headers to send with the request
+    # @param [Hash] properties
+    #   a list of matrix properties
+    #
+    def upload(path_or_io, path, properties = {}, headers = {})
+      file = if path_or_io.is_a?(File)
+               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)
+
+      client.put(endpoint, { file: file }, headers)
+    end
+
+    #
+    # Upload an artifact with the given SHA checksum. Consult the artifactory
+    # documentation for the possible responses when the checksums fail to
+    # match.
+    #
+    # @see Repository#upload More syntax examples
+    #
+    # @example Upload an artifact with a checksum
+    #   repo = Repository.new('libs-release-local')
+    #   repo.upload_with_checksum('/local/file', '/remote/path', 'ABCD1234')
+    #
+    # @param (see Repository#upload)
+    # @param [String] checksum
+    #   the SHA1 checksum of the artifact to upload
+    #
+    def upload_with_checksum(path_or_io, path, checksum, properties = {})
+      upload(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 Repository#upload More syntax examples
+    #
+    # @example Upload an artifact with a checksum
+    #   repo = Repositor.new('libs-release-local')
+    #   repo.upload_from_archive('/local/archive', '/remote/path')#
+    #
+    # @param (see Repository#upload)
+    #
+    def upload_from_archive(path_or_io, path, properties = {})
+      upload(path_or_io, path, properties,
+        'X-Explode-Archive' => true,
+      )
+    end
+
+    #
+    # The list of artifacts in this repository on the remote artifactory
+    # server.
+    #
+    # @see Artifact.search Search syntax examples
+    #
+    # @example Get the list of artifacts for a repository
+    #   repo = Repository.new('libs-release-local')
+    #   repo.artifacts #=> [#<Resource::Artifacts>, ...]
+    #
+    # @return [Collection::Artifact]
+    #   the list of artifacts
+    #
+    def artifacts
+      @artifacts ||= Collection::Artifact.new(self, repos: key) do
+        Resource::Artifact.search(name: '.*', repos: key)
+      end
+    end
+
+    #
+    #
+    #
+    def files
+      response = get("/api/storage/#{url_safe_key}", {
+        deep:            0,
+        listFolders:     0,
+        mdTimestamps:    0,
+        includeRootPath: 0,
+      })
+
+      response['children']
+    end
+
+    private
+
+    #
+    #
+    #
+    def url_safe_key
+      @url_safe_key ||= URI.escape(key.to_s)
+    end
+
+    #
+    # @todo Make this a mixin or reusable?
+    #
+    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
+  end
+end

data/lib/artifactory/resources/system.rb

@@ -0,0 +1,114 @@
+module Artifactory
+  class Resource::System < Resource::Base
+    class << self
+      #
+      # Get general system information.
+      #
+      # @example Get the system information
+      #   System.info #=> "..."
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [String]
+      #   a "table" of the system information as returned by the API
+      #
+      def info(options = {})
+        client = extract_client!(options)
+        client.get('/api/system')
+      end
+
+      #
+      # Check the status of the Artifactory server and API. This method will
+      # always return a boolean response, so it's safe to call without
+      # exception handling.
+      #
+      # @example Wait until the Artifactory server is ready
+      #   until System.ping
+      #     sleep(0.5)
+      #     print '.'
+      #   end
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [Boolean]
+      #   true if the Artifactory server is ready, false otherwise
+      #
+      def ping(options = {})
+        client = extract_client!(options)
+        !!client.get('/api/system/ping')
+      rescue Error::ConnectionError
+        false
+      end
+
+      #
+      # Get the current system configuration as XML.
+      #
+      # @example Get the current configuration
+      #   System.configuration
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [REXML::Document]
+      #   the parsed XML document
+      #
+      def configuration(options = {})
+        client   = extract_client!(options)
+        response = client.get('/api/system/configuration')
+
+        REXML::Document.new(response)
+      end
+
+      #
+      # Update the configuration with the given XML.
+      #
+      # @example Update the configuration
+      #   new_config = File.new('/path/to/new.xml')
+      #   System.update_configuration(new_config)
+      #
+      # @param [Hash] options
+      #   the list of options
+      # @param [File] xml
+      #   a pointer to the file descriptor of the XML to upload
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      def update_configuration(xml, options = {})
+        client = extract_client!(options)
+        client.post('/api/system/configuration', xml)
+      end
+
+      #
+      # Get the version information from the server.
+      #
+      # @example Get the version information
+      #   System.version #=> { ... }
+      #
+      # @param [Hash] options
+      #   the list of options
+      #
+      # @option options [Artifactory::Client] :client
+      #   the client object to make the request with
+      #
+      # @return [Hash]
+      #   the parsed JSON from the response
+      #
+      def version(options = {})
+        client = extract_client!(options)
+        client.get('/api/system/version')
+      end
+    end
+  end
+end