pdc 0.1.0

data/examples/pdc_resource_tests.rb

@@ -0,0 +1,173 @@
+require_relative '../lib/pdc'
+require_relative '../spec/spec_helper'
+
+WebMock.disable! # this uses real server
+
+#### service config ####
+def token
+  script_path = File.expand_path(File.dirname(__FILE__))
+  token_path = File.join(script_path, '.token', 'pdc.prod')
+  File.read(token_path).chomp.tap { |x| puts "Using token :#{x.ai}" }
+rescue Errno::ENOENT => e
+  puts "Hey! did you forget to create #{token_path.ai} \n".red
+  raise e
+end
+
+#### server config ####
+
+server = {
+  local: {
+    site: 'http://localhost:8000',
+    token: nil
+  },
+
+  prod: {
+    site: 'https://pdc.engineering.redhat.com',
+    token: ->() { token } # read token only if needed
+  }
+}
+
+# server to use
+pdc = server[:prod]
+pdc = server[:local]
+
+PDC.configure do |config|
+  config.site = pdc[:site]
+  auth_token = pdc[:token]
+  config.token = pdc[:token].call if auth_token
+  config.requires_token = auth_token.present? # to_bool
+end
+
+#### product ####
+
+describe PDC::V1::Product do
+  let(:product_class) { PDC::V1::Product }
+  it 'has_many product_versions' do
+    p1 = product_class.scoped.first
+    p1.product_versions.must_be_instance_of Array
+    # TODO: continue the after release and release-variants
+  end
+end
+
+#### Arch ####
+
+describe PDC::V1::Arch do
+  let(:arch_class) { PDC::V1::Arch }
+
+  describe 'contents!' do
+    it 'only returns contents of a page' do
+      arches = arch_class.scoped.contents!
+      (0..arch_class.count).must_include arches.length
+
+      arches_pg1 = arch_class.page(1).contents!
+      arches_pg1.must_equal arches
+
+      arches_pg2 = arch_class.page(2).contents!
+      arches_pg1.wont_equal arches_pg2
+    end
+  end
+
+  describe '#page' do
+    it 'can access page(2)' do
+      arch_class.page(2).must_be_instance_of PDC::Resource::Relation
+    end
+
+    it 'must return resource on page(2).to_a' do
+      arches = arch_class.page(2).to_a
+      arches.first.must_be_instance_of arch_class
+    end
+  end
+
+  describe '#each_page' do
+    it 'must be able to iterate using map' do
+      resource_count = arch_class.count
+
+      arches = arch_class.scoped.map(&:name)
+      arches.must_be_instance_of Array
+      arches.first.must_be_instance_of String
+
+      arches.count.must_equal resource_count
+    end
+  end
+
+  describe '#page_size' do
+    it 'must return all records when page_size is -1' do
+      all_arches = arch_class.page_size(-1).to_a
+      all_arches_count = arch_class.count
+      all_arches.must_be_instance_of Array
+      all_arches.length.must_equal all_arches_count
+    end
+
+    it 'all! is the same as page_size(-1)' do
+      all_arches = arch_class.all!
+      all_arches_count = arch_class.count
+      all_arches.must_be_instance_of Array
+      all_arches.length.must_equal all_arches_count
+    end
+  end
+
+  describe '#find' do
+  end
+end
+
+### TODO: debug - remove this
+A = PDC::V1::Arch
+R = PDC::V1::Release
+RV = PDC::V1::ReleaseVariant
+###
+
+describe PDC::V1::Release do
+  let(:release_class) { PDC::V1::Release }
+  let(:existing_release) { release_class.all!.first }
+
+  describe '#find' do
+    it 'must return a record' do
+      found = release_class.find(existing_release.release_id)
+      found.must_be_instance_of release_class
+      found.release_id.must_equal existing_release.release_id
+    end
+  end
+
+  describe '#variants' do
+    let(:sat_6_at_rhel_7) { release_class.find('satellite-6.0.4@rhel-7') }
+    let(:release_variant_class) { PDC::V1::ReleaseVariant }
+
+    it 'must be a HasMany association' do
+      skip 'TODO implement Assocations'
+      variants_relation = sat_6_at_rhel_7.variants
+      variants_relation.must_be_instance_of PDC::Resource::HasManyAssociation
+    end
+
+    it 'must be able to call all! to return all variants ' do
+      variants_relation = sat_6_at_rhel_7.variants
+      ap variants_relation.params
+      release_id = variants_relation.params[:release]
+      release_id.must_equal sat_6_at_rhel_7.id
+
+      all_variants = variants_relation.all!
+      expected = variants_relation.where(page_size: -1).to_a
+
+      all_variants.must_equal expected
+    end
+
+    it 'must return release variants for a release' do
+      variants_relation = sat_6_at_rhel_7.variants
+      variants = variants_relation.to_a
+      variants.must_be_instance_of Array
+      variants.length.must_be :>=, 1
+      variants.first.must_be_instance_of release_variant_class
+    end
+  end
+end
+
+describe PDC::V1::ReleaseVariant do
+  let(:release_class) { PDC::V1::Release }
+  let(:release_variant_class) { PDC::V1::ReleaseVariant }
+  let(:a_variant) { release_variant_class.all!.first }
+
+  describe '#release' do
+    it 'must fetch the release it belongs to' do
+      a_variant.release.must_be_instance_of release_class
+    end
+  end
+end

data/examples/pdc_test_cache.rb

@@ -0,0 +1,48 @@
+require 'benchmark'
+require_relative '../lib/pdc'
+require_relative '../spec/spec_helper'
+
+WebMock.disable!
+PDC.configure do |config|
+  # dev server
+  config.site = 'https://pdc.host.dev.eng.pek2.redhat.com/'
+  config.cache_store = ActiveSupport::Cache.lookup_store(
+    :file_store, [File.join(ENV['TMPDIR'] || '/tmp', 'cache')])
+  config.log_level = :info
+end
+
+ActiveSupport::Notifications.subscribe "http_cache.faraday" do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  puts " >>> ".yellow + "cache: #{event.payload[:cache_status]}"
+  ap event.payload
+end
+
+def benchmark(description, opts = {}, &block)
+  puts "Running: #{description}"
+
+  initial = Benchmark.measure(&block)
+  repeat = Benchmark.measure(&block)
+
+  puts "Initial :  #{initial.to_s.chomp} >> #{initial.real.round(2).ai}"
+  puts "Repeat  :  #{repeat.to_s.chomp} >> #{repeat.real.round(2).ai} \n"
+end
+
+def main
+  benchmark "fetch all" do
+    PDC::V1::Release.all
+  end
+
+  benchmark "fetch with page number" do
+    PDC::V1::Release.page(2).contents!
+  end
+
+  benchmark "fetch with page number and size" do
+    PDC::V1::Release.page(2).page_size(30).contents!
+  end
+
+  benchmark "fetch with page number and size and query condition" do
+    PDC::V1::Release.page(2).page_size(30).where(active: true).contents!
+  end
+end
+
+main if __FILE__ == $PROGRAM_NAME

data/examples/prod_failures.rb

@@ -0,0 +1,26 @@
+require_relative '../lib/pdc'
+require 'ap'
+
+class PDC::V1::NonExistingResource < PDC::Base
+end
+
+def main
+  PDC.configure do |config|
+    config.site = 'https://pdc.engineering.redhat.com/'
+    # don't even bother fetching the token, this has to
+    # fail anyway
+    config.requires_token = false
+    config.log_level = :debug
+  end
+
+  begin
+    resources = PDC::V1::NonExistingResource.all.to_a
+    ap resources
+  rescue PDC::ResourceNotFound => e
+    ap e
+    puts "Got resource not found as expected: #{e.response.status}".yellowish
+    ap e.message
+  end
+end
+
+main if __FILE__ == $0

data/examples/prod_pdc.rb

@@ -0,0 +1,14 @@
+require './lib/pdc'
+require 'ap'
+
+def main
+  PDC.configure do |config|
+    config.site = 'https://pdc.engineering.redhat.com'
+    config.log_level = :debug
+  end
+
+  releases = PDC::V1::Release.all!.to_a
+  ap releases
+end
+
+main if __FILE__ == $0

data/lib/pdc/base.rb

@@ -0,0 +1,14 @@
+module PDC
+  class Base
+    extend ActiveModel::Naming
+
+    include PDC::Logging
+    include PDC::Resource::Identity
+    include PDC::Resource::Attributes
+    include PDC::Resource::Scopes
+    include PDC::Resource::RestApi
+
+    scope :page, ->(value) { where(:page => value) }
+    scope :page_size, ->(value) { where(:page_size => value) }
+  end
+end

data/lib/pdc/config.rb

@@ -0,0 +1,157 @@
+require 'faraday-http-cache'
+require 'curb'
+
+module PDC
+  # This class is the main access point for all PDC::Resource instances.
+  #
+  # The client must be initialized with an options hash containing
+  # configuration options.  The available options are:
+  #
+  #   :site               => 'http://localhost:2990',
+  #   :ssl_verify_mode    => OpenSSL::SSL::VERIFY_PEER,
+  #   :use_ssl            => true,
+  #   :username           => nil,
+  #   :password           => nil,
+  #   :auth_type          => :oauth
+  #   :proxy_address      => nil
+  #   :proxy_port         => nil
+  #
+  # See the PDC::Base class methods for all of the available methods on these accessor
+  # objects.
+
+  class << self
+    Config = Struct.new(
+      :site,
+      :api_root,
+
+      :use_ssl,
+      :ssl_verify_mode,
+
+      :requires_token,
+      :token_obtain_path,
+      :token,
+
+      :log_level,
+      :enable_logging,
+      :logger,
+
+      :cache_store,
+      :disable_caching,
+    ) do
+      def initialize
+        # site config
+        self.site                = 'http://localhost:8000'
+        self.api_root            = 'rest_api/'
+        self.use_ssl             = true
+        self.ssl_verify_mode     = OpenSSL::SSL::VERIFY_PEER
+
+        # token and authentication
+        self.requires_token      = true
+        self.token_obtain_path   = 'v1/auth/token/obtain/'
+        self.token               = nil
+
+        # logger config
+        self.log_level           = :warn
+        self.enable_logging      = true
+        self.logger              = PDC.logger
+
+        self.cache_store         = nil
+        self.disable_caching     = false
+      end
+    end
+
+    def configure
+      @config = Config.new
+      begin
+        yield(@config) if block_given?
+      rescue NoMethodError => e
+        raise ConfigError, e
+      end
+
+      apply_config
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def config=(new_config)
+      @config = new_config
+      apply_config
+      @config
+    end
+
+    def token_url
+      URI.join(api_url, config.token_obtain_path)
+    end
+
+    def api_url
+      URI.join(config.site, config.api_root)
+    end
+
+    def token
+      config.token || fetch_token
+    end
+
+    private
+
+      def apply_config
+        reset_logger
+        reset_base_connection
+      end
+
+      def reset_logger
+        PDC.logger = Logger.new(nil) unless config.enable_logging
+        logger.level = Logger.const_get(config.log_level.upcase)
+      end
+
+      # resets and returns the +Faraday+ +connection+ object
+      def reset_base_connection
+        headers = PDC::Request.default_headers
+        PDC::Base.connection = Faraday.new(url: api_url, headers: headers) do |c|
+          c.request   :append_slash_to_path
+          c.request   :authorization, 'Token', token if config.requires_token
+
+          c.response  :logger, config.logger
+          c.response  :pdc_paginator
+          c.response  :pdc_json_parser
+          c.response  :raise_error
+          c.response  :pdc_raise_error
+
+          c.use       FaradayMiddleware::FollowRedirects
+
+          unless config.disable_caching
+            c.use       Faraday::HttpCache, store: cache_store,
+                          logger: PDC.logger,
+                          instrumenter: ActiveSupport::Notifications
+          end
+          c.adapter   Faraday.default_adapter
+        end
+      end
+
+      def cache_store
+        config.cache_store || ActiveSupport::Cache.lookup_store(:memory_store)
+      end
+
+      def fetch_token
+        curl = Curl::Easy.new(token_url.to_s) do |request|
+          request.headers['Accept'] = 'application/json'
+          request.http_auth_types = :gssnegotiate
+
+          # The curl man page (http://curl.haxx.se/docs/manpage.html)
+          # specifes setting a fake username when using Negotiate auth,
+          # and use ':' in their example.
+          request.username = ':'
+        end
+        curl.perform
+        if curl.response_code != 200
+          logger.info "Obtain token from #{token_url} failed: #{curl.body_str}"
+          error = { token_url: token_url, body: curl.body, code: curl.response_code }
+          raise PDC::TokenFetchFailed, error
+        end
+        result = JSON.parse(curl.body_str)
+        curl.close
+        result['token']
+      end
+  end
+end

data/lib/pdc/errors.rb

@@ -0,0 +1,8 @@
+module PDC
+  # Base for all PDC generated errors
+  class Error < StandardError; end
+
+  class ConfigError < Error; end
+
+  class InvalidPathError < Error; end
+end

data/lib/pdc/http/errors.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+
+module PDC
+  class JsonParseError < Error; end
+
+  class ResponseError < Error
+    extend Forwardable
+
+    def_instance_delegators :response, :status, :body
+    attr_reader :response
+
+    def initialize(args = {})
+      @response = args[:response]
+      @args = args
+    end
+  end
+
+  class JsonError < ResponseError
+    def message
+      summary = detail || response.body
+      "Error: #{status} - #{summary}"
+    end
+
+    private
+
+    # returns details in json response if any, else nil
+    def detail
+      @detail ||= json[:detail]
+    end
+
+    # tries to parse response body as a json
+    def json
+      @json ||= begin
+                  MultiJson.load(response.body, symbolize_keys: true)
+                rescue MultiJson::ParseError
+                  {}
+                end
+    end
+  end
+
+  class ResourceNotFound < JsonError; end
+  class TokenFetchFailed < JsonError; end
+end

data/lib/pdc/http/request/append_slash.rb

@@ -0,0 +1,19 @@
+module PDC
+  class Request::AppendSlashToPath < Faraday::Middleware
+    include PDC::Logging
+
+    Faraday::Request.register_middleware :append_slash_to_path => self
+
+    def call(env)
+      logger.debug "\n..... append slash ..........................................".green
+      logger.debug self.class
+      logger.debug env.url
+
+      path = env.url.path
+      env.url.path = path + '/' unless path.ends_with?('/')
+
+      logger.debug "...  after adding / #{env.url.path}: #{env.url.ai}"
+      @app.call(env)
+    end
+  end
+end

data/lib/pdc/http/request.rb

@@ -0,0 +1,12 @@
+require 'pdc/http/request/append_slash'
+
+module PDC
+  module Request
+    def self.default_headers
+      {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json'
+      }
+    end
+  end
+end

data/lib/pdc/http/response/pagination.rb

@@ -0,0 +1,43 @@
+module PDC::Response
+  class Paginator < Faraday::Response::Middleware
+    include PDC::Logging
+
+    Faraday::Response.register_middleware :pdc_paginator => self
+
+    def parse(json)
+      logger.debug "\n.....paginate json .....................................".redish
+
+      metadata = json[:metadata]
+      logger.debug metadata
+      return json unless paginated?(metadata)
+
+      metadata[PDC::Resource::PAGINATION] = {
+        resource_count:   metadata.delete(:count),
+
+        # TODO: decide if this is okay to discard the
+        # schema://host:port/ of the next and previous
+
+        next_page:        request_uri(metadata.delete(:next)),
+        previous_page:    request_uri(metadata.delete(:previous)),
+      }
+
+      logger.debug '... after parsing pagination data:'.green
+      logger.debug metadata
+      json
+    end
+
+    private
+
+    def request_uri(uri)
+      return unless uri
+      URI(uri).request_uri
+    end
+
+    def paginated?(metadata)
+      metadata[:count].is_a?(Numeric) &&
+      metadata.key?(:next) &&
+      metadata.key?(:previous)
+    end
+
+  end
+end

data/lib/pdc/http/response/parser.rb

@@ -0,0 +1,62 @@
+require 'multi_json'
+
+module PDC::Response
+  # Converts body into JSON data, metadata and errors
+  class Parser < Faraday::Response::Middleware
+    include PDC::Logging
+
+    Faraday::Response.register_middleware :pdc_json_parser => self
+
+    def parse(body)
+      logger.debug "\n.....parse to json .....................................".yellow
+      logger.debug self.class
+
+      logger.debug "... parsing #{body.ai.truncate(55)}"
+      begin
+        json = MultiJson.load(body, symbolize_keys: true)
+      rescue MultiJson::ParseError => e
+        raise PDC::JsonParseError, e
+      end
+
+      res = {
+        data:     extract_data(json),     # Always an Array
+        errors:   extract_errors(json),   #
+        metadata: extract_metadata(json)  # a hash
+      }
+    end
+
+    private
+
+    def extract_data(json)
+      return [] if error?(json)
+      return json[:results] if has_metadata?(json)
+      Array.wrap(json)
+    end
+
+    def extract_errors(json)
+      error?(json) ? json[:details] : []
+    end
+
+    def extract_metadata(json)
+      return json.except(:details, :results) if has_metadata?(json)
+      data_only?(json) ? { count: json.length, next: nil, previous: nil } : {}
+    end
+
+    def has_metadata?(json)
+      return false if data_only?(json) || error?(json)
+
+      json[:results].is_a?(Array) &&
+        json[:count].is_a?(Numeric) &&
+        json.key?(:next) &&
+        json.key?(:previous)
+    end
+
+    def error?(json)
+      json.is_a?(Hash) && json.keys == [:detail]
+    end
+
+    def data_only?(json)
+      json.is_a? Array
+    end
+  end
+end

data/lib/pdc/http/response/raise_error.rb

@@ -0,0 +1,13 @@
+module PDC
+  class Response::RaiseError < Faraday::Response::Middleware
+    Faraday::Response.register_middleware pdc_raise_error: self
+
+    def on_complete(env)
+      raise PDC::ResourceNotFound, response_values(env) if env[:status] == 404
+    end
+
+    def response_values(env)
+      { response: env.response, request: env.request }
+    end
+  end
+end

data/lib/pdc/http/response.rb

@@ -0,0 +1,3 @@
+require 'pdc/http/response/parser'
+require 'pdc/http/response/pagination'
+require 'pdc/http/response/raise_error'

data/lib/pdc/http/result.rb

@@ -0,0 +1,28 @@
+module PDC::Http
+  # encapsulates +http+ response
+  class Result
+    attr_reader :url, :body, :status
+
+    def initialize(response)
+      @body = HashWithIndifferentAccess.new(response.body)
+      @status = response.status
+      @url = response.env.url
+    end
+
+    def data
+      body[:data]
+    end
+
+    def metadata
+      body[:metadata] || {}
+    end
+
+    def pagination
+      metadata[PDC::Resource::PAGINATION] || {}
+    end
+
+    def errors
+      body[:errors] || []
+    end
+  end
+end

data/lib/pdc/http.rb

@@ -0,0 +1,12 @@
+module PDC
+  module Request
+  end
+
+  module Response
+  end
+end
+
+require 'pdc/http/errors'
+require 'pdc/http/result'
+require 'pdc/http/request'
+require 'pdc/http/response'