deimos-ruby 1.4.0.pre.beta7 → 1.5.0.pre.beta2

data/lib/deimos/avro_data_coder.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Deimos
-  # Base class for the encoder / decoder classes.
-  class AvroDataCoder
-    attr_accessor :schema, :namespace, :config, :schema_store
-
-    # @param schema [String]
-    # @param namespace [String]
-    # @param schema_store [AvroTurf::SchemaStore]
-    def initialize(schema:, namespace:, schema_store: nil)
-      @schema = schema
-      @namespace = namespace
-      @schema_store = schema_store ||
-                      AvroTurf::SchemaStore.new(path: Deimos.config.schema.path)
-    end
-
-    # @param schema [String]
-    # @return [Avro::Schema]
-    def avro_schema(schema=nil)
-      schema ||= @schema
-      @schema_store.find(schema, @namespace)
-    end
-
-  private
-
-    # @return [AvroTurf]
-    def avro_turf
-      @avro_turf ||= AvroTurf.new(
-        schemas_path: Deimos.config.schema.path,
-        schema_store: @schema_store
-      )
-      @avro_turf
-    end
-
-    # @return [AvroTurf::Messaging]
-    def avro_turf_messaging
-      @avro_turf_messaging ||= AvroTurf::Messaging.new(
-        schema_store: @schema_store,
-        registry_url: Deimos.config.schema.registry_url,
-        schemas_path: Deimos.config.schema.path,
-        namespace: @namespace
-      )
-    end
-
-    # Generate a key schema from the given value schema and key ID. This
-    # is used when encoding or decoding keys from an existing value schema.
-    # @param key_id [Symbol]
-    # @return [Hash]
-    def _generate_key_schema(key_id)
-      return @key_schema if @key_schema
-
-      value_schema = @schema_store.find(@schema, @namespace)
-      key_field = value_schema.fields.find { |f| f.name == key_id.to_s }
-      name = _key_schema_name(@schema)
-      @key_schema = {
-        'type' => 'record',
-        'name' => name,
-        'namespace' => @namespace,
-        'doc' => "Key for #{@namespace}.#{@schema}",
-        'fields' => [
-          {
-            'name' => key_id,
-            'type' => key_field.type.type_sym.to_s
-          }
-        ]
-      }
-      @schema_store.add_schema(@key_schema)
-      @key_schema
-    end
-
-    # @param value_schema [Hash]
-    # @return [String]
-    def _field_name_from_schema(value_schema)
-      raise "Schema #{@schema} not found!" if value_schema.nil?
-      if value_schema['fields'].nil? || value_schema['fields'].empty?
-        raise "Schema #{@schema} has no fields!"
-      end
-
-      value_schema['fields'][0]['name']
-    end
-
-    # @param schema [String]
-    # @return [String]
-    def _key_schema_name(schema)
-      "#{schema.gsub('-value', '')}_key"
-    end
-  end
-end

data/lib/deimos/avro_data_decoder.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'avro_turf/messaging'
-require 'deimos/avro_data_coder'
-
-module Deimos
-  # Service Object to decode avro messages
-  class AvroDataDecoder < AvroDataCoder
-    # Decode some data.
-    # @param payload [Hash|String]
-    # @param schema [String]
-    # @return [Hash]
-    def decode(payload, schema: nil)
-      schema ||= @schema
-      avro_turf_messaging.decode(payload, schema_name: schema)
-    end
-
-    # Decode against a local schema.
-    # @param payload [Hash]
-    # @param schema [String]
-    # @return [Hash]
-    def decode_local(payload, schema: nil)
-      schema ||= @schema
-      avro_turf.decode(payload, schema_name: schema, namespace: @namespace)
-    end
-
-    # @param payload [String] the encoded key.
-    # @param key_id [String|Symbol]
-    # @return [Object] the decoded key (int/long/string).
-    def decode_key(payload, key_id)
-      key_schema = _generate_key_schema(key_id)
-      field_name = _field_name_from_schema(key_schema)
-      decode(payload, schema: key_schema['name'])[field_name]
-    end
-  end
-end

data/lib/deimos/avro_data_encoder.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'avro_turf/messaging'
-require 'deimos/avro_data_coder'
-
-module Deimos
-  # Service Object to decode Avro messages.
-  class AvroDataEncoder < AvroDataCoder
-    # @param payload [Hash]
-    # @param schema [String]
-    # @return [String]
-    def encode_local(payload, schema: nil)
-      schema ||= @schema
-      Avro::SchemaValidator.validate!(avro_schema(schema), payload,
-                                      recursive: true,
-                                      fail_on_extra_fields: true)
-      avro_turf.encode(payload, schema_name: schema, namespace: @namespace)
-    rescue Avro::IO::AvroTypeError
-      # throw a more detailed error
-      value_schema = @schema_store.find(schema, @namespace)
-      Avro::SchemaValidator.validate!(value_schema, payload)
-    end
-
-    # @param payload [Hash]
-    # @param schema [String]
-    # @param topic [String]
-    # @return [String]
-    def encode(payload, schema: nil, topic: nil)
-      schema ||= @schema
-      Avro::SchemaValidator.validate!(avro_schema(schema), payload,
-                                      recursive: true,
-                                      fail_on_extra_fields: true)
-      avro_turf_messaging.encode(payload, schema_name: schema, subject: topic)
-    rescue Avro::IO::AvroTypeError
-      # throw a more detailed error
-      schema = @schema_store.find(@schema, @namespace)
-      Avro::SchemaValidator.validate!(schema, payload)
-    end
-
-    # @param key_id [Symbol|String]
-    # @param key [Object]
-    # @param topic [String]
-    # @return [String] the encoded key.
-    def encode_key(key_id, key, topic=nil)
-      key_schema = _generate_key_schema(key_id)
-      field_name = _field_name_from_schema(key_schema)
-      payload = { field_name => key }
-      encode(payload, schema: key_schema['name'], topic: topic)
-    end
-  end
-end

data/lib/deimos/monkey_patches/schema_store.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'avro_turf/schema_store'
-
-# Allows us to add in-memory schemas to the schema store in
-# addition to the ones stored in the file system.
-class AvroTurf::SchemaStore
-  attr_accessor :schemas
-
-  # @param schema_hash [Hash]
-  def add_schema(schema_hash)
-    name = schema_hash['name']
-    namespace = schema_hash['namespace']
-    full_name = Avro::Name.make_fullname(name, namespace)
-    return if @schemas.key?(full_name)
-
-    Avro::Schema.real_parse(schema_hash, @schemas)
-  end
-end

data/lib/deimos/publish_backend.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Deimos
-  # Abstract class for all publish backends.
-  class PublishBackend
-    class << self
-      # @param producer_class [Class < Deimos::Producer]
-      # @param messages [Array<Deimos::Message>]
-      def publish(producer_class:, messages:)
-        Deimos.config.logger.info(
-          message: 'Publishing messages',
-          topic: producer_class.topic,
-          payloads: messages.map do |message|
-            {
-              payload: message.payload,
-              key: message.key
-            }
-          end
-        )
-        execute(producer_class: producer_class, messages: messages)
-      end
-
-      # @param producer_class [Class < Deimos::Producer]
-      # @param messages [Array<Deimos::Message>]
-      def execute(producer_class:, messages:)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/spec/avro_data_decoder_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-describe Deimos::AvroDataDecoder do
-
-  let(:decoder) do
-    decoder = described_class.new(schema: 'MySchema',
-                                  namespace: 'com.my-namespace')
-    allow(decoder).to(receive(:decode)) { |payload| payload }
-    decoder
-  end
-
-  it 'should decode a key' do
-    # reset stub from TestHelpers
-    allow(described_class).to receive(:new).and_call_original
-    expect(decoder.decode_key({ 'test_id' => '123' }, 'test_id')).to eq('123')
-  end
-
-end

data/spec/avro_data_encoder_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'avro_turf/messaging'
-
-describe Deimos::AvroDataEncoder do
-
-  let(:encoder) do
-    encoder = described_class.new(schema: 'MySchema',
-                                  namespace: 'com.my-namespace')
-    allow(encoder).to(receive(:encode)) { |payload| payload }
-    encoder
-  end
-
-  specify 'generate_key_schema' do
-    expect_any_instance_of(AvroTurf::SchemaStore).
-      to receive(:add_schema).with(
-        'type' => 'record',
-        'name' => 'MySchema_key',
-        'namespace' => 'com.my-namespace',
-        'doc' => 'Key for com.my-namespace.MySchema',
-        'fields' => [
-          {
-            'name' => 'test_id',
-            'type' => 'string'
-          }
-        ]
-      )
-    encoder.send(:_generate_key_schema, 'test_id')
-  end
-
-  it 'should encode a key' do
-    # reset stub from TestHelpers
-    allow(described_class).to receive(:new).and_call_original
-    expect(encoder.encode_key('test_id', '123')).to eq('test_id' => '123')
-  end
-
-end

data/spec/updateable_schema_store_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-describe AvroTurf::SchemaStore do
-
-  it 'should add an in-memory schema' do
-    schema_store = described_class.new(path: Deimos.config.schema.path)
-    schema_store.load_schemas!
-    found_schema = schema_store.find('MySchema', 'com.my-namespace').as_json
-    expect(found_schema['name']).to eq('MySchema')
-    expect(found_schema['namespace']).to eq('com.my-namespace')
-    expect(found_schema['fields'].size).to eq(2)
-    expect(found_schema['fields'][0]['type']['type_sym']).to eq('string')
-    expect(found_schema['fields'][0]['name']).to eq('test_id')
-    new_schema = {
-      'namespace' => 'com.my-namespace',
-      'name' => 'MyNewSchema',
-      'type' => 'record',
-      'doc' => 'Test schema',
-      'fields' => [
-        {
-          'name' => 'my_id',
-          'type' => 'int',
-          'doc' => 'test int'
-        }
-      ]
-    }
-    schema_store.add_schema(new_schema)
-    found_schema = schema_store.find('MyNewSchema', 'com.my-namespace').
-      as_json
-    expect(found_schema['name']).to eq('MyNewSchema')
-    expect(found_schema['namespace']).to eq('com.my-namespace')
-    expect(found_schema['fields'].size).to eq(1)
-    expect(found_schema['fields'][0]['type']['type_sym']).to eq('int')
-    expect(found_schema['fields'][0]['name']).to eq('my_id')
-  end
-end