rancher.rb 0.1.0

data/lib/rancher/collection.rb

@@ -0,0 +1,42 @@
+require 'rancher/resource'
+module Rancher
+  # A Collection of Resources
+  class Collection < Resource
+    include Enumerable
+
+    def initialize(data)
+      @data = data[:data] if data.key?(:data)
+      super(data)
+    end
+
+    def create(attrs)
+      attrs = attrs.meta if attrs.is_a?(Rancher::Resource)
+
+      Rancher.post get_link('self'), attrs
+    end
+
+    def remove!(id_or_obj)
+      id = id_or_obj.get_id if id_or_obj.is_a?(Rancher::Resource)
+      link = get_link('self') + "/#{id}"
+
+      Rancher.delete link
+    end
+
+    def each
+      return @data.enum_for(:each) unless block_given?
+
+      @data.each { |d| yield d }
+    end
+
+    private
+
+    def schema_field(name)
+      type_name = get_type
+      type = Rancher.types[type_name.to_sym]
+
+      type.collection_field(name) if type
+
+      type
+    end
+  end
+end

data/lib/rancher/configurable.rb

@@ -0,0 +1,84 @@
+module Rancher
+  # Configuration options for {Client}, defaulting to values
+  # in {Default}
+  module Configurable
+    # @!attribute api_endpoint
+    #   @return [String] Base URL for API requests. default: http://localhost:8080/v1/projects/1p1
+    # @!attribute access_key
+    #   @return [String] Access Key from inside rancher
+    # @!attribute [w] secret_key
+    #   @return [String] Secrete Key form inside rancher
+    # @!attribute connection_options
+    #   @see https://github.com/lostisland/faraday
+    #   @return [Hash] Configure connection options for Faraday
+    # @!attribute middleware
+    #   @see https://Rancher.com/lostisland/faraday
+    #   @return [Faraday::Builder or Faraday::RackBuilder] Configure middleware for Faraday
+    # @!attribute proxy
+    #   @see https://Rancher.com/lostisland/faraday
+    #   @return [String] URI for proxy server
+    # @!attribute user_agent
+    #   @return [String] Configure User-Agent header for requests.
+
+    attr_accessor :access_key, :secret_key, :connection_options,
+                  :middleware, :proxy, :user_agent, :default_media_type
+    attr_writer :api_endpoint
+
+    class << self
+      # List of configurable keys for {Rancher::Client}
+      # @return [Array] of option keys
+      def keys
+        @keys ||= [
+          :api_endpoint,
+          :access_key,
+          :secret_key,
+          :connection_options,
+          :default_media_type,
+          :middleware,
+          :proxy,
+          :user_agent
+        ]
+      end
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      Rancher::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Rancher::Default.options[key])
+      end
+      self
+    end
+    alias_method :setup, :reset!
+
+    # Compares client options to a Hash of requested options
+    #
+    # @param opts [Hash] Options to compare with current client options
+    # @return [Boolean]
+    def same_options?(opts)
+      opts.hash == options.hash
+    end
+
+    def api_endpoint
+      File.join(@api_endpoint, '')
+    end
+
+    private
+
+    def options
+      Hash[Rancher::Configurable.keys.map do |key|
+        [key, instance_variable_get(:"@#{key}")]
+        end
+      ]
+    end
+
+    def fetch_access_key_and_secret(overrides = {})
+      opts = options.merge(overrides)
+      opts.values_at :access_key, :secret_key
+    end
+  end
+end

data/lib/rancher/connection.rb

@@ -0,0 +1,192 @@
+require 'sawyer'
+require 'rancher/authentication'
+require 'rancher/classify'
+module Rancher
+
+  # Network layer for API clients.
+  module Connection
+
+    include Rancher::Authentication
+    include Rancher::Classify
+
+    # Header keys that can be passed in options hash to {#get},{#head}
+    CONVENIENCE_HEADERS = Set.new([:accept, :content_type])
+
+    # Make a HTTP GET request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+    def get(url, options = {})
+      request :get, url, parse_query_and_convenience_headers(options)
+    end
+
+    # Make a HTTP POST request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Body and header params for request
+    # @return [Sawyer::Resource]
+    def post(url, options = {})
+      request :post, url, options
+    end
+
+    # Make a HTTP PUT request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Body and header params for request
+    # @return [Sawyer::Resource]
+    def put(url, options = {})
+      request :put, url, options
+    end
+
+    # Make a HTTP PATCH request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Body and header params for request
+    # @return [Sawyer::Resource]
+    def patch(url, options = {})
+      request :patch, url, options
+    end
+
+    # Make a HTTP DELETE request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+    def delete(url, options = {})
+      request :delete, url, options
+    end
+
+    # Make a HTTP HEAD request
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @return [Sawyer::Resource]
+    def head(url, options = {})
+      request :head, url, parse_query_and_convenience_headers(options)
+    end
+
+    # Make one or more HTTP GET requests, optionally fetching
+    # the next page of results from URL in Link response header based
+    # on value in {#auto_paginate}.
+    #
+    # @param url [String] The path, relative to {#api_endpoint}
+    # @param options [Hash] Query and header params for request
+    # @param block [Block] Block to perform the data concatination of the
+    #   multiple requests. The block is called with two parameters, the first
+    #   contains the contents of the requests so far and the second parameter
+    #   contains the latest response.
+    # @return [Sawyer::Resource]
+    def paginate(url, options = {}, &block)
+      opts = parse_query_and_convenience_headers(options.dup)
+      if @auto_paginate || @per_page
+        opts[:query][:per_page] ||=  @per_page || (@auto_paginate ? 100 : nil)
+      end
+
+      data = request(:get, url, opts.dup)
+
+      if @auto_paginate
+        while @last_response.rels[:next] && rate_limit.remaining > 0
+          @last_response = @last_response.rels[:next].get(:headers => opts[:headers])
+          if block_given?
+            yield(data, @last_response)
+          else
+            data.concat(@last_response.data) if @last_response.data.is_a?(Array)
+          end
+        end
+
+      end
+
+      data
+    end
+
+    # Hypermedia agent for the Rancher API
+    #
+    # @return [Sawyer::Agent]
+    def agent
+      @agent ||= Sawyer::Agent.new(endpoint, sawyer_options) do |http|
+        http.headers[:accept] = default_media_type
+        http.headers[:content_type] = "application/json"
+        http.headers[:user_agent] = user_agent
+        if basic_authenticated?
+          http.basic_auth(@access_key, @secret_key)
+        end
+      end
+    end
+
+    # Fetch the root resource for the API
+    #
+    # @return [Sawyer::Resource]
+    def root
+      get ""
+    end
+
+    # Response for last HTTP request
+    #
+    # @return [Sawyer::Response]
+    def last_response
+      @last_response if defined? @last_response
+    end
+
+    protected
+
+    def endpoint
+      api_endpoint
+    end
+
+    private
+
+    def reset_agent
+      @agent = nil
+    end
+
+    def request(method, path, data, options = {})
+      if data.is_a?(Hash)
+        options[:query]   = data.delete(:query) || {}
+        options[:headers] = data.delete(:headers) || {}
+        if accept = data.delete(:accept)
+          options[:headers][:accept] = accept
+        end
+      end
+
+      @last_response = response = agent.call(method, URI::Parser.new.escape(path.to_s), data, options)
+      classify response.data
+    end
+
+    # Executes the request, checking if it was successful
+    #
+    # @return [Boolean] True on success, false otherwise
+    def boolean_from_response(method, path, options = {})
+      request(method, path, options)
+      @last_response.status == 204
+    rescue Rancher::NotFound
+      false
+    end
+
+
+    def sawyer_options
+      opts = {}
+      conn_opts = @connection_options
+      conn_opts[:builder] = @middleware if @middleware
+      conn_opts[:proxy] = @proxy if @proxy
+      opts[:faraday] = Faraday.new(conn_opts)
+
+      opts
+    end
+
+    def parse_query_and_convenience_headers(options)
+      headers = options.delete(:headers) { Hash.new }
+      CONVENIENCE_HEADERS.each do |h|
+        if header = options.delete(h)
+          headers[h] = header
+        end
+      end
+      query = options.delete(:query)
+      opts = {:query => options}
+      opts[:query].merge!(query) if query && query.is_a?(Hash)
+      opts[:headers] = headers unless headers.empty?
+
+      opts
+    end
+  end
+end

data/lib/rancher/default.rb

@@ -0,0 +1,109 @@
+require 'rancher/middleware/follow_redirects'
+require 'rancher/response/raise_error'
+require 'rancher/version'
+
+module Rancher
+  # Default configuration options for {Client}
+  module Default
+    # Default API endpoint
+    API_ENDPOINT = 'http://localhost:8080/v1/projects/1a5'.freeze
+
+    # Default User Agent header string
+    USER_AGENT   = "Rancher Ruby Gem #{Rancher::VERSION}".freeze
+
+    # Default media type
+    MEDIA_TYPE   = 'application/json'.freeze
+
+    # In Faraday 0.9, Faraday::Builder was renamed to Faraday::RackBuilder
+    RACK_BUILDER_CLASS = defined?(Faraday::RackBuilder) ? Faraday::RackBuilder : Faraday::Builder
+
+    # Default Faraday middleware stack
+    MIDDLEWARE = RACK_BUILDER_CLASS.new do |builder|
+      builder.use Rancher::Middleware::FollowRedirects
+      builder.use Rancher::Response::RaiseError
+      builder.adapter Faraday.default_adapter
+    end
+
+    class << self
+      # Configuration options
+      # @return [Hash]
+      def options
+        Hash[Rancher::Configurable.keys.map { |key| [key, send(key)] }]
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def api_endpoint
+        ENV['RANCHER_API_ENDPOINT'] || API_ENDPOINT
+      end
+
+      # Default pagination preference from ENV
+      # @return [String]
+      def auto_paginate
+        ENV['RANCHER_AUTO_PAGINATE']
+      end
+
+      # Default OAuth app key from ENV
+      # @return [String]
+      def access_key
+        ENV['RANCHER_CLIENT_ID']
+      end
+
+      # Default OAuth app secret from ENV
+      # @return [String]
+      def secret_key
+        ENV['RANCHER_SECRET']
+      end
+
+      # Default options for Faraday::Connection
+      # @return [Hash]
+      def connection_options
+        {
+          headers: {
+            accept: default_media_type,
+            user_agent: user_agent
+          }
+        }
+      end
+
+      # Default media type from ENV or {MEDIA_TYPE}
+      # @return [String]
+      def default_media_type
+        ENV['RANCHER_DEFAULT_MEDIA_TYPE'] || MEDIA_TYPE
+      end
+
+      # Default middleware stack for Faraday::Connection
+      # from {MIDDLEWARE}
+      # @return [String]
+      def middleware
+        MIDDLEWARE
+      end
+
+      # Default pagination page size from ENV
+      # @return [Fixnum] Page size
+      def per_page
+        page_size = ENV['RANCHER_PER_PAGE']
+
+        page_size.to_i if page_size
+      end
+
+      # Default proxy server URI for Faraday connection from ENV
+      # @return [String]
+      def proxy
+        ENV['RANCHER_PROXY']
+      end
+
+      # Default User-Agent header string from ENV or {USER_AGENT}
+      # @return [String]
+      def user_agent
+        ENV['RANCHER_USER_AGENT'] || USER_AGENT
+      end
+
+      # Default web endpoint from ENV or {WEB_ENDPOINT}
+      # @return [String]
+      def web_endpoint
+        ENV['RANCHER_WEB_ENDPOINT'] || WEB_ENDPOINT
+      end
+    end
+  end
+end

data/lib/rancher/error.rb

@@ -0,0 +1,241 @@
+module Rancher
+  # Custom error class for rescuing from all Rancher errors
+  class Error < StandardError
+
+    # Returns the appropriate Rancher::Error subclass based
+    # on status and response message
+    #
+    # @param [Hash] response HTTP response
+    # @return [Rancher::Error]
+    def self.from_response(response)
+      status  = response[:status].to_i
+      body    = response[:body].to_s
+      headers = response[:response_headers]
+
+      if klass =  case status
+                  when 400      then Rancher::BadRequest
+                  when 401      then error_for_401(headers)
+                  when 403      then error_for_403(body)
+                  when 404      then Rancher::NotFound
+                  when 405      then Rancher::MethodNotAllowed
+                  when 406      then Rancher::NotAcceptable
+                  when 409      then Rancher::Conflict
+                  when 415      then Rancher::UnsupportedMediaType
+                  when 422      then Rancher::UnprocessableEntity
+                  when 400..499 then Rancher::ClientError
+                  when 500      then Rancher::InternalServerError
+                  when 501      then Rancher::NotImplemented
+                  when 502      then Rancher::BadGateway
+                  when 503      then Rancher::ServiceUnavailable
+                  when 500..599 then Rancher::ServerError
+                  end
+        klass.new(response)
+      end
+    end
+
+    def initialize(response=nil)
+      @response = response
+      super(build_error_message)
+    end
+
+    # Documentation URL returned by the API for some errors
+    #
+    # @return [String]
+    def documentation_url
+      data[:documentation_url] if data.is_a? Hash
+    end
+
+    # Returns most appropriate error for 401 HTTP status code
+    # @private
+    def self.error_for_401(headers)
+      if Rancher::OneTimePasswordRequired.required_header(headers)
+        Rancher::OneTimePasswordRequired
+      else
+        Rancher::Unauthorized
+      end
+    end
+
+    # Returns most appropriate error for 403 HTTP status code
+    # @private
+    def self.error_for_403(body)
+      if body =~ /rate limit exceeded/i
+        Rancher::TooManyRequests
+      elsif body =~ /login attempts exceeded/i
+        Rancher::TooManyLoginAttempts
+      elsif body =~ /abuse/i
+        Rancher::AbuseDetected
+      elsif body =~ /repository access blocked/i
+        Rancher::RepositoryUnavailable
+      else
+        Rancher::Forbidden
+      end
+    end
+
+    # Array of validation errors
+    # @return [Array<Hash>] Error info
+    def errors
+      if data && data.is_a?(Hash)
+        data[:errors] || []
+      else
+        []
+      end
+    end
+
+    private
+
+    def data
+      @data ||=
+        if (body = @response[:body]) && !body.empty?
+          if body.is_a?(String) &&
+            @response[:response_headers] &&
+            @response[:response_headers][:content_type] =~ /json/
+
+            Sawyer::Agent.serializer.decode(body)
+          else
+            body
+          end
+        else
+          nil
+        end
+    end
+
+    def response_message
+      case data
+      when Hash
+        data[:message]
+      when String
+        data
+      end
+    end
+
+    def response_error
+      "Error: #{data[:error]}" if data.is_a?(Hash) && data[:error]
+    end
+
+    def response_error_summary
+      return nil unless data.is_a?(Hash) && !Array(data[:errors]).empty?
+
+      summary = "\nError summary:\n"
+      summary << data[:errors].map do |hash|
+        hash.map { |k,v| "  #{k}: #{v}" }
+      end.join("\n")
+
+      summary
+    end
+
+    def build_error_message
+      return nil if @response.nil?
+
+      message =  "#{@response[:method].to_s.upcase} "
+      message << redact_url(@response[:url].to_s) + ": "
+      message << "#{@response[:status]} - "
+      message << "#{response_message}" unless response_message.nil?
+      message << "#{response_error}" unless response_error.nil?
+      message << "#{response_error_summary}" unless response_error_summary.nil?
+      message << " // See: #{documentation_url}" unless documentation_url.nil?
+      message
+    end
+
+    def redact_url(url_string)
+      %w[secret_key access_token].each do |token|
+        url_string.gsub!(/#{token}=\S+/, "#{token}=(redacted)") if url_string.include? token
+      end
+      url_string
+    end
+  end
+
+  # Raised on errors in the 400-499 range
+  class ClientError < Error; end
+
+  # Raised when Rancher returns a 400 HTTP status code
+  class BadRequest < ClientError; end
+
+  # Raised when Rancher returns a 401 HTTP status code
+  class Unauthorized < ClientError; end
+
+  # Raised when Rancher returns a 401 HTTP status code
+  # and headers include "X-Rancher-OTP"
+  class OneTimePasswordRequired < ClientError
+    #@private
+    OTP_DELIVERY_PATTERN = /required; (\w+)/i
+
+    #@private
+    def self.required_header(headers)
+      OTP_DELIVERY_PATTERN.match headers['X-Rancher-OTP'].to_s
+    end
+
+    # Delivery method for the user's OTP
+    #
+    # @return [String]
+    def password_delivery
+      @password_delivery ||= delivery_method_from_header
+    end
+
+    private
+
+    def delivery_method_from_header
+      if match = self.class.required_header(@response[:response_headers])
+        match[1]
+      end
+    end
+  end
+
+  # Raised when Rancher returns a 403 HTTP status code
+  class Forbidden < ClientError; end
+
+  # Raised when Rancher returns a 403 HTTP status code
+  # and body matches 'rate limit exceeded'
+  class TooManyRequests < Forbidden; end
+
+  # Raised when Rancher returns a 403 HTTP status code
+  # and body matches 'login attempts exceeded'
+  class TooManyLoginAttempts < Forbidden; end
+
+  # Raised when Rancher returns a 403 HTTP status code
+  # and body matches 'abuse'
+  class AbuseDetected < Forbidden; end
+
+  # Raised when Rancher returns a 403 HTTP status code
+  # and body matches 'repository access blocked'
+  class RepositoryUnavailable < Forbidden; end
+
+  # Raised when Rancher returns a 404 HTTP status code
+  class NotFound < ClientError; end
+
+  # Raised when Rancher returns a 405 HTTP status code
+  class MethodNotAllowed < ClientError; end
+
+  # Raised when Rancher returns a 406 HTTP status code
+  class NotAcceptable < ClientError; end
+
+  # Raised when Rancher returns a 409 HTTP status code
+  class Conflict < ClientError; end
+
+  # Raised when Rancher returns a 414 HTTP status code
+  class UnsupportedMediaType < ClientError; end
+
+  # Raised when Rancher returns a 422 HTTP status code
+  class UnprocessableEntity < ClientError; end
+
+  # Raised on errors in the 500-599 range
+  class ServerError < Error; end
+
+  # Raised when Rancher returns a 500 HTTP status code
+  class InternalServerError < ServerError; end
+
+  # Raised when Rancher returns a 501 HTTP status code
+  class NotImplemented < ServerError; end
+
+  # Raised when Rancher returns a 502 HTTP status code
+  class BadGateway < ServerError; end
+
+  # Raised when Rancher returns a 503 HTTP status code
+  class ServiceUnavailable < ServerError; end
+
+  # Raised when client fails to provide valid Content-Type
+  class MissingContentType < ArgumentError; end
+
+  # Raised when a method requires an application access_key
+  # and secret but none is provided
+  class ApplicationCredentialsRequired < StandardError; end
+end