schema_registry_client 0.0.6 → 0.0.7

data/lib/schema_registry_client/schema/protobuf.rb

@@ -1,32 +1,32 @@
 # frozen_string_literal: true
 
-require 'google/protobuf'
-require 'google/protobuf/well_known_types'
-require 'google/protobuf/descriptor_pb'
-require 'schema_registry_client/output/proto_text'
-require 'schema_registry_client/schema/base'
-require 'schema_registry_client/wire'
-
-class SchemaRegistry
+require "google/protobuf"
+require "google/protobuf/well_known_types"
+require "google/protobuf/descriptor_pb"
+require "schema_registry_client/output/proto_text"
+require "schema_registry_client/schema/base"
+require "schema_registry_client/wire"
+
+module SchemaRegistry
   module Schema
     class Protobuf < Base
       class << self
         def schema_type
-          'PROTOBUF'
+          "PROTOBUF"
         end
 
         def schema_text(message, schema_name: nil)
           file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-                              message
-                            else
-                              message.class.descriptor.file_descriptor
-                            end
+            message
+          else
+            message.class.descriptor.file_descriptor
+          end
           SchemaRegistry::Output::ProtoText.output(file_descriptor.to_proto)
         end
 
         def encode(message, stream, schema_name: nil)
           _, indexes = find_index(message.class.descriptor.to_proto,
-                                  message.class.descriptor.file_descriptor.to_proto.message_type)
+            message.class.descriptor.file_descriptor.to_proto.message_type)
 
           if indexes == [0]
             SchemaRegistry::Wire.write_int(stream, 0)
@@ -60,7 +60,7 @@ class SchemaRegistry
           all_files = ObjectSpace.each_object(Google::Protobuf::FileDescriptor).to_a
           all_files.each do |file_desc|
             file_path = file_desc.name
-            next if file_path.start_with?('google/protobuf/') # skip built-in protos
+            next if file_path.start_with?("google/protobuf/") # skip built-in protos
 
             @all_schemas[file_path] = file_desc
           end
@@ -69,13 +69,13 @@ class SchemaRegistry
         def dependencies(message)
           load_schemas! unless @all_schemas&.any?
           file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-                              message
-                            else
-                              message.class.descriptor.file_descriptor
-                            end
+            message
+          else
+            message.class.descriptor.file_descriptor
+          end
 
           deps = file_descriptor.to_proto.dependency.to_a
-                                .reject { |d| d.start_with?('google/protobuf/') }
+            .reject { |d| d.start_with?("google/protobuf/") }
           deps.to_h do |dep|
             dependency_schema = @all_schemas[dep]
             [dependency_schema.name, dependency_schema]
@@ -117,12 +117,12 @@ class SchemaRegistry
           descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(full_name)
           unless descriptor
             msg = "Could not find schema for #{full_name}. " \
-                  'Make sure the corresponding .proto file has been compiled and loaded.'
+                  "Make sure the corresponding .proto file has been compiled and loaded."
             raise msg
           end
 
           path = find_descriptor(indexes, descriptor.file_descriptor.to_proto.message_type)
-          correct_message = Google::Protobuf::DescriptorPool.generated_pool.lookup("#{package}.#{path.join('.')}")
+          correct_message = Google::Protobuf::DescriptorPool.generated_pool.lookup("#{package}.#{path.join(".")}")
           correct_message.msgclass.decode(encoded)
         end
       end

data/lib/schema_registry_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
-  VERSION = '0.0.6'
+module SchemaRegistry
+  VERSION = "0.0.7"
 end

data/lib/schema_registry_client/wire.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Wire
     class << self
       # Write an int with zig-zag encoding. Copied from Avro.

data/lib/schema_registry_client.rb

@@ -1,156 +1,160 @@
 # frozen_string_literal: true
 
-require 'logger'
-require 'json'
-require 'schema_registry_client/confluent_schema_registry'
-require 'schema_registry_client/cached_confluent_schema_registry'
-require 'schema_registry_client/schema/protobuf'
-require 'schema_registry_client/schema/proto_json_schema'
-require 'schema_registry_client/schema/avro'
-
-class SchemaRegistry
+require "logger"
+require "json"
+require "schema_registry_client/confluent_schema_registry"
+require "schema_registry_client/cached_confluent_schema_registry"
+require "schema_registry_client/schema/protobuf"
+require "schema_registry_client/schema/proto_json_schema"
+require "schema_registry_client/schema/avro"
+
+module SchemaRegistry
   class SchemaNotFoundError < StandardError; end
   class SchemaError < StandardError; end
 
-  # Provides a way to encode and decode messages without having to embed schemas
-  # in the encoded data. Confluent's Schema Registry[1] is used to register
-  # a schema when encoding a message -- the registry will issue a schema id that
-  # will be included in the encoded data alongside the actual message. When
-  # decoding the data, the schema id will be used to look up the writer's schema
-  # from the registry.
-  #
-  # 1: https://github.com/confluentinc/schema-registry
-  # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/serdes-protobuf.html
-  # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
-  MAGIC_BYTE = [0].pack('C').freeze
-
-  # Instantiate a new SchemaRegistry instance with the given configuration.
-  #
-  # registry             - A schema registry object that responds to all methods in the
-  #                        SchemaRegistry::ConfluentSchemaRegistry interface.
-  # registry_url         - The String URL of the schema registry that should be used.
-  # schema_context       - Schema registry context name (optional)
-  # registry_path_prefix - The String URL path prefix used to namespace schema registry requests (optional).
-  # logger               - The Logger that should be used to log information (optional).
-  # proxy                - Forward the request via  proxy (optional).
-  # user                 - User for basic auth (optional).
-  # password             - Password for basic auth (optional).
-  # ssl_ca_file          - Name of file containing CA certificate (optional).
-  # client_cert          - Name of file containing client certificate (optional).
-  # client_key           - Name of file containing client private key to go with client_cert (optional).
-  # client_key_pass      - Password to go with client_key (optional).
-  # client_cert_data     - In-memory client certificate (optional).
-  # client_key_data      - In-memory client private key to go with client_cert_data (optional).
-  # connect_timeout      - Timeout to use in the connection with the schema registry (optional).
-  # resolv_resolver      - Custom domain name resolver (optional).
-  # schema_type          - A SchemaRegistry::Schema::Base subclass.
-  def initialize( # rubocop:disable Metrics/ParameterLists
-    registry: nil,
-    registry_url: nil,
-    schema_context: nil,
-    registry_path_prefix: nil,
-    logger: nil,
-    proxy: nil,
-    user: nil,
-    password: nil,
-    ssl_ca_file: nil,
-    client_cert: nil,
-    client_key: nil,
-    client_key_pass: nil,
-    client_cert_data: nil,
-    client_key_data: nil,
-    connect_timeout: nil,
-    resolv_resolver: nil,
-    schema_type: SchemaRegistry::Schema::Protobuf
-  )
-    @logger = logger || Logger.new($stderr)
-    @registry = registry || SchemaRegistry::CachedConfluentSchemaRegistry.new(
-      SchemaRegistry::ConfluentSchemaRegistry.new(
-        registry_url,
-        schema_context: schema_context,
-        logger: @logger,
-        proxy: proxy,
-        user: user,
-        password: password,
-        ssl_ca_file: ssl_ca_file,
-        client_cert: client_cert,
-        client_key: client_key,
-        client_key_pass: client_key_pass,
-        client_cert_data: client_cert_data,
-        client_key_data: client_key_data,
-        path_prefix: registry_path_prefix,
-        connect_timeout: connect_timeout,
-        resolv_resolver: resolv_resolver
-      )
-    )
-    @schema = schema_type
-  end
-
   class << self
     attr_accessor :avro_schema_path
   end
 
-  # Encodes a message using the specified schema.
-  # @param message [Object] The message that should be encoded. Must be compatible with the schema.
-  # @param subject [String] The subject name the schema should be registered under in the schema registry (optional).
-  # @param schema_name [String] the name of the schema to use for encoding (optional).
-  # @return [String] the encoded data.
-  def encode(message, subject: nil, schema_text: nil, schema_name: nil)
-    id = register_schema(message, subject, schema_text: schema_text, schema_name: schema_name)
-
-    stream = StringIO.new
-    # Always start with the magic byte.
-    stream.write(MAGIC_BYTE)
+  class Client
+    # Provides a way to encode and decode messages without having to embed schemas
+    # in the encoded data. Confluent's Schema Registry[1] is used to register
+    # a schema when encoding a message -- the registry will issue a schema id that
+    # will be included in the encoded data alongside the actual message. When
+    # decoding the data, the schema id will be used to look up the writer's schema
+    # from the registry.
+    #
+    # 1: https://github.com/confluentinc/schema-registry
+    # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/serdes-protobuf.html
+    # https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
+    MAGIC_BYTE = [0].pack("C").freeze
+
+    # Instantiate a new SchemaRegistry instance with the given configuration.
+    #
+    # registry             - A schema registry object that responds to all methods in the
+    #                        SchemaRegistry::ConfluentSchemaRegistry interface.
+    # registry_url         - The String URL of the schema registry that should be used.
+    # schema_context       - Schema registry context name (optional)
+    # registry_path_prefix - The String URL path prefix used to namespace schema registry requests (optional).
+    # logger               - The Logger that should be used to log information (optional).
+    # proxy                - Forward the request via  proxy (optional).
+    # user                 - User for basic auth (optional).
+    # password             - Password for basic auth (optional).
+    # ssl_ca_file          - Name of file containing CA certificate (optional).
+    # client_cert          - Name of file containing client certificate (optional).
+    # client_key           - Name of file containing client private key to go with client_cert (optional).
+    # client_key_pass      - Password to go with client_key (optional).
+    # client_cert_data     - In-memory client certificate (optional).
+    # client_key_data      - In-memory client private key to go with client_cert_data (optional).
+    # connect_timeout      - Timeout to use in the connection with the schema registry (optional).
+    # resolv_resolver      - Custom domain name resolver (optional).
+    # schema_type          - A SchemaRegistry::Schema::Base subclass.
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      registry: nil,
+      registry_url: nil,
+      schema_context: nil,
+      registry_path_prefix: nil,
+      logger: nil,
+      proxy: nil,
+      user: nil,
+      password: nil,
+      ssl_ca_file: nil,
+      client_cert: nil,
+      client_key: nil,
+      client_key_pass: nil,
+      client_cert_data: nil,
+      client_key_data: nil,
+      connect_timeout: nil,
+      resolv_resolver: nil,
+      schema_type: SchemaRegistry::Schema::Protobuf
+    )
+      @logger = logger || Logger.new($stderr)
+      @registry = registry || SchemaRegistry::CachedConfluentSchemaRegistry.new(
+        SchemaRegistry::ConfluentSchemaRegistry.new(
+          registry_url,
+          schema_context: schema_context,
+          logger: @logger,
+          proxy: proxy,
+          user: user,
+          password: password,
+          ssl_ca_file: ssl_ca_file,
+          client_cert: client_cert,
+          client_key: client_key,
+          client_key_pass: client_key_pass,
+          client_cert_data: client_cert_data,
+          client_key_data: client_key_data,
+          path_prefix: registry_path_prefix,
+          connect_timeout: connect_timeout,
+          resolv_resolver: resolv_resolver
+        )
+      )
+      @schema = schema_type
+    end
 
-    # The schema id is encoded as a 4-byte big-endian integer.
-    stream.write([id].pack('N'))
+    # Encodes a message using the specified schema.
+    # @param message [Object] The message that should be encoded. Must be compatible with the schema.
+    # @param subject [String] The subject name the schema should be registered under in the schema registry (optional).
+    # @param schema_name [String] the name of the schema to use for encoding (optional).
+    # @return [String] the encoded data.
+    def encode(message, subject: nil, schema_text: nil, schema_name: nil)
+      id = register_schema(message, subject, schema_text: schema_text, schema_name: schema_name)
 
-    @schema.encode(message, stream, schema_name: schema_name)
-    stream.string
-  end
+      stream = StringIO.new
+      # Always start with the magic byte.
+      stream.write(MAGIC_BYTE)
 
-  # Decodes data into the original message.
-  #
-  # @param data [String] a string containing encoded data.
-  # @return [Object] the decoded data.
-  def decode(data)
-    stream = StringIO.new(data)
+      # The schema id is encoded as a 4-byte big-endian integer.
+      stream.write([id].pack("N"))
 
-    # The first byte is MAGIC!!!
-    magic_byte = stream.read(1)
+      @schema.encode(message, stream, schema_name: schema_name)
+      stream.string
+    end
 
-    raise "Expected data to begin with a magic byte, got `#{magic_byte.inspect}`" if magic_byte != MAGIC_BYTE
+    # Decodes data into the original message.
+    #
+    # @param data [String] a string containing encoded data.
+    # @return [Object] the decoded data.
+    def decode(data)
+      stream = StringIO.new(data)
 
-    # The schema id is a 4-byte big-endian integer.
-    schema_id = stream.read(4).unpack1('N')
-    schema = @registry.fetch(schema_id)
-    @schema.decode(stream, schema)
-  rescue Excon::Error::NotFound
-    raise SchemaNotFoundError, "Schema with id: #{schema_id} is not found on registry"
-  end
+      # The first byte is MAGIC!!!
+      magic_byte = stream.read(1)
 
-  private
+      raise "Expected data to begin with a magic byte, got `#{magic_byte.inspect}`" if magic_byte != MAGIC_BYTE
 
-  def register_schema(message, subject, schema_text: nil, schema_name: nil)
-    schema_text ||= @schema.schema_text(message, schema_name: schema_name)
-    return if @registry.registered?(schema_text, subject)
+      # The schema id is a 4-byte big-endian integer.
+      schema_id = stream.read(4).unpack1("N")
+      schema = @registry.fetch(schema_id)
+      @schema.decode(stream, schema)
+    rescue Excon::Error::NotFound
+      raise SchemaNotFoundError, "Schema with id: #{schema_id} is not found on registry"
+    end
 
-    # register dependencies first
-    dependencies = @schema.dependencies(message)
-    versions = dependencies.map do |name, dependency|
-      result = register_schema(dependency, name)
-      @registry.fetch_version(result, name)
+    private
+
+    def register_schema(message, subject, schema_text: nil, schema_name: nil)
+      schema_text ||= @schema.schema_text(message, schema_name: schema_name)
+      return if @registry.registered?(schema_text, subject)
+
+      # register dependencies first
+      dependencies = @schema.dependencies(message)
+      versions = dependencies.map do |name, dependency|
+        result = register_schema(dependency, name)
+        @registry.fetch_version(result, name)
+      end
+
+      @registry.register(subject,
+        schema_text,
+        references: dependencies.keys.map.with_index do |dependency, i|
+          {
+            name: dependency,
+            subject: dependency,
+            version: versions[i]
+          }
+        end,
+        schema_type: @schema.schema_type)
     end
 
-    @registry.register(subject,
-                       schema_text,
-                       references: dependencies.keys.map.with_index do |dependency, i|
-                         {
-                           name: dependency,
-                           subject: dependency,
-                           version: versions[i]
-                         }
-                       end,
-                       schema_type: @schema.schema_type)
   end
+
 end

data/schema_registry_client.gemspec

@@ -1,33 +1,33 @@
 # frozen_string_literal: true
 
-lib = File.expand_path('lib', __dir__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'schema_registry_client/version'
+require "schema_registry_client/version"
 
 Gem::Specification.new do |spec|
-  spec.name = 'schema_registry_client'
+  spec.name = "schema_registry_client"
   spec.version = SchemaRegistry::VERSION
-  spec.authors = ['Daniel Orner']
-  spec.email = ['daniel.orner@flipp.com']
-  spec.summary = 'Confluent Schema Registry client with support for Avro and Protobuf'
-  spec.homepage = 'https://github.com/flipp-oss/schema_registry_client'
-  spec.license = 'MIT'
-  spec.required_ruby_version = '>= 3.0'
+  spec.authors = ["Daniel Orner"]
+  spec.email = ["daniel.orner@flipp.com"]
+  spec.summary = "Confluent Schema Registry client with support for Avro and Protobuf"
+  spec.homepage = "https://github.com/flipp-oss/schema_registry_client"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
 
-  spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   spec.files = `git ls-files -z`.split("\x0")
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.add_dependency 'avro'
-  spec.add_dependency 'excon'
-  spec.add_dependency 'google-protobuf'
+  spec.add_dependency "avro"
+  spec.add_dependency "excon"
+  spec.add_dependency "google-protobuf"
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.2'
-  spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'standardrb'
-  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "standardrb"
+  spec.add_development_dependency "webmock"
 end