nypl_ruby_util 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a102fc9301f667018c0ae2c9f2fc26c5525f8ac2fad91b35b980da52731b67b2
+  data.tar.gz: 4a3ac1f699931ca2432196a3c4997948ded44e6e470ec3bd958cb639b0731eca
+SHA512:
+  metadata.gz: 9cb6c355ffc6d948bd800e7e6b69267115f67f49cb644aa14212d296556a0e95acdd2d8004e88f31f9671e38d4eca6a8ce349a7a18bc52fe694c990e6f6a561c
+  data.tar.gz: 59e711f7bebcacfe8dc24520ec8c2bcde349d2bffabc1ad40386622cf55096bdde87ee7aff4f088f70408d76466e67d1a0be634f7d96457ba5265b3304b15e70

data/lib/directory.rb

@@ -0,0 +1,3 @@
+class Directory
+  # PLATFORM_API_BASE_URL
+end

data/lib/errors.rb

@@ -0,0 +1,10 @@
+class NYPLError < StandardError
+  attr_reader :object
+
+  def initialize(object='')
+    @object = object
+  end
+end
+
+class AvroError < NYPLError
+end

data/lib/kinesis_client.rb

@@ -0,0 +1,49 @@
+require 'securerandom'
+require 'aws-sdk-kinesis'
+require_relative 'nypl_avro'
+require_relative 'errors'
+# Model representing the result message posted to Kinesis stream about everything that has gone on here -- good, bad, or otherwise.
+
+class KinesisClient
+  attr_reader :config, :avro
+
+  def initialize(config)
+    @config = config
+    @avro = nil
+
+    if config[:schema_string]
+      @avro = NYPLAvro.by_name(config[:schema_string])
+    end
+
+  end
+
+  def <<(json_message)
+    p '<< ', config[:schema_string], avro
+    if config[:schema_string]
+      message = avro.encode(json_message)
+    else
+      message = json_message
+    end
+
+    client = Aws::Kinesis::Client.new
+    partition_key = (config[:partition_key] ? json_message[config[:partition_key]] : SecureRandom.hex(20)).hash.to_s
+
+    resp = client.put_record({
+      stream_name: config[:stream_name],
+      data: message,
+      partition_key: partition_key
+      })
+
+      return_hash = {}
+
+      if resp.successful?
+        return_hash["code"] = "200"
+        return_hash["message"] = json_message, resp
+        $logger.info("Message sent to HoldRequestResult #{json_message}, #{resp}") if $logger
+      else
+        $logger.error("message" => "FAILED to send message to HoldRequestResult #{json_message}, #{resp}.") if $logger
+        raise NYPLError.new json_message, resp
+      end
+      return_hash
+  end
+end

data/lib/kms_client.rb

@@ -0,0 +1,27 @@
+require 'aws-sdk-kms'
+require 'base64'
+
+class KmsClient
+  @@kms = nil
+
+  def initialize(options = {})
+    options ||= {}
+    @kms = self.class.aws_kms_client(options)
+  end
+
+  def decrypt(cipher)
+    # Assume value is base64 encoded:
+    decoded = Base64.decode64 cipher
+    decrypted = @kms.decrypt ciphertext_blob: decoded
+    decrypted[:plaintext]
+  end
+
+  def self.aws_kms_client(options)
+    params = {
+      region: 'us-east-1',
+      stub_responses: ENV['APP_ENV'] == 'test'
+    }.merge(options)
+    @@kms = Aws::KMS::Client.new(params) if @@kms.nil?
+    @@kms
+  end
+end

data/lib/nypl_avro.rb

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'avro'
+require 'base64'
+
+require_relative 'errors'
+require_relative 'directory'
+
+class NYPLAvro
+  def initialize (schemaString)
+    begin
+      @schema = Avro::Schema.parse(schemaString)
+    rescue Exception => e
+      raise AvroError.new(e), "Failed to parse schema string: \"#{schemaString}\""
+    end
+
+    @reader = Avro::IO::DatumReader.new(@schema)
+  end
+
+  def decode(encoded_data_string, base64 = true)
+    avro_string = base64 ? Base64.decode64(encoded_data_string) : encoded_data_string
+    stringreader = StringIO.new(avro_string)
+    bin_decoder = Avro::IO::BinaryDecoder.new(stringreader)
+    begin
+      read_value = @reader.read(bin_decoder)
+    rescue Exception => e
+      raise AvroError.new(e), "Error decoding data using #{@schema.name} schema"
+    end
+
+    read_value
+  end
+
+  def encode(decoded_data, base64 = true)
+    bin_encoder = Avro::IO::DatumWriter.new(@schema)
+    buffer = StringIO.new
+    encoder = Avro::IO::BinaryEncoder.new(buffer)
+
+    begin
+      bin_encoder.write(decoded_data, encoder)
+    rescue Avro::IO::AvroTypeError => e
+      raise AvroError.new(e), "Error encoding data using #{@schema.name} schema due to #{e.message}"
+    end
+
+    buffer.rewind
+    result = buffer.read
+    base64 ? Base64.encode64(result) : result
+  end
+
+  def self.by_name (name)
+    require 'net/http'
+    require 'uri'
+
+    uri = URI.parse("#{ENV["PLATFORM_API_BASE_URL"]}current-schemas/#{name}")
+    begin
+      response = Net::HTTP.get_response(uri)
+    rescue Exception => e
+      raise AvroError.new(e), "Failed to retrieve #{name} schema: #{e.message}"
+    end
+
+    begin
+      response_hash = JSON.parse(response.body)
+    rescue JSON::ParserError => e
+      raise AvroError.new(e), "Retrieved #{name} schema is malformed: #{response.body}"
+    end
+
+    raise AvroError.new, "Failed to retrieve #{name} schema: statusCode=#{response_hash["statusCode"]}" if response_hash["statusCode"] >= 400
+    raise AvroError.new, "Retrieved #{name} schema is malformed" if response_hash["data"].nil? || response_hash["data"]["schema"].nil?
+
+    self.new response_hash["data"]["schema"]
+  end
+end

data/lib/nypl_ruby_util.rb

@@ -0,0 +1,28 @@
+require 'nypl_log_formatter'
+require 'nypl_sierra_api_client'
+require_relative 'kms_client'
+require_relative 'platform_api_client'
+require_relative 'directory'
+require_relative 'nypl_avro'
+require_relative 'errors'
+require_relative 'kinesis_client'
+
+class NYPLRubyUtil
+  class SierraApiClient < SierraApiClient
+  end
+
+  class NyplLogFormatter < NyplLogFormatter
+  end
+
+  class KmsClient < KmsClient
+  end
+
+  class NYPLAvro < NYPLAvro
+  end
+
+  class PlatformApiClient < PlatformApiClient
+  end
+
+  class KinesisClient < KinesisClient
+  end
+end

data/lib/platform_api_client.rb

@@ -0,0 +1,105 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+require_relative 'kms_client'
+
+class PlatformApiClient
+  attr_reader :authenticated, :client_id, :client_secret, :error_options, :oauth_site
+  attr_accessor :access_token
+
+  def initialize(options = {})
+    raise 'Missing config: NYPL_OAUTH_ID is unset' if ENV['NYPL_OAUTH_ID'].nil? || ENV['NYPL_OAUTH_ID'].empty?
+    raise 'Missing config: NYPL_OAUTH_SECRET is unset' if ENV['NYPL_OAUTH_SECRET'].nil? || ENV['NYPL_OAUTH_SECRET'].empty?
+
+    kms_client = KmsClient.new(options[:kms_options])
+    @client_id = kms_client.decrypt(ENV['NYPL_OAUTH_ID'])
+    @client_secret = kms_client.decrypt(ENV['NYPL_OAUTH_SECRET'])
+
+    @oauth_site = ENV['NYPL_OAUTH_URL']
+    @authenticated = options[:authenticated] || true
+    @error_options = default_errors.merge(options[:errors] || {})
+  end
+
+  def get (path)
+
+    authenticate! if authenticated
+
+    uri = URI.parse("#{ENV['PLATFORM_API_BASE_URL']}#{path}")
+
+    $logger.debug "Getting from platform api", { uri: uri }
+
+    begin
+      request = Net::HTTP::Get.new(uri)
+      request["Authorization"] = "Bearer #{access_token}" if authenticated
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme === 'https') do |http|
+        http.request(request)
+      end
+
+      $logger.debug "Got platform api response", { code: response.code, body: response.body }
+
+      parse_json_response response, path
+
+    rescue Exception => e
+      raise StandardError.new(e), "Failed to retrieve #{path} #{e.message}"
+    end
+  end
+
+  private
+
+  def parse_json_response (response, path)
+    code = response.code.to_i
+    if code < 400
+      JSON.parse(response.body)
+    elsif error_options[code]
+      instance_exec(response, path, &error_options[code])
+    else
+      raise "Error interpretting response for path #{path}: (#{response.code}): #{response.body}"
+      {}
+    end
+  end
+
+  # Authorizes the request.
+  def authenticate!
+    # NOOP if we've already authenticated
+    return nil if ! access_token.nil?
+
+    uri = URI.parse("#{oauth_site}oauth/token")
+    request = Net::HTTP::Post.new(uri)
+    request.basic_auth(client_id, client_secret)
+    request.set_form_data(
+      "grant_type" => "client_credentials"
+    )
+
+    req_options = {
+      use_ssl: uri.scheme == "https",
+      request_timeout: 500
+    }
+
+    response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
+      http.request(request)
+    end
+
+    if response.code == '200'
+      access_token = JSON.parse(response.body)["access_token"]
+    else
+      nil
+    end
+  end
+
+  def default_errors
+    {
+      401 => lambda do |response, path|
+        if @try_count < 1
+          # Likely an expired access-token; Wipe it for next run
+          @try_count += 1
+          access_token = nil
+          get(path)
+        else
+          raise "Error interpretting response for path #{path}: (#{response.code}): #{response.body}"
+        end
+      end
+    }
+  end
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: nypl_ruby_util
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Appel
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-07-13 00:00:00.000000000 Z
+dependencies: []
+description: A repository of common utilities for NYPL Ruby application
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/directory.rb
+- lib/errors.rb
+- lib/kinesis_client.rb
+- lib/kms_client.rb
+- lib/nypl_avro.rb
+- lib/nypl_ruby_util.rb
+- lib/platform_api_client.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: A repository of common utilities for NYPL Ruby application
+test_files: []