tigerbeetle 0.0.40 → 0.17.8

data/lib/tb_client/shared_lib.rb

@@ -1,66 +0,0 @@
-module TBClient
-  module SharedLib
-    class << self
-      NATIVE_DIR = File.expand_path('native', __dir__).freeze
-      PKG_DIR = File.expand_path('../../ext/tb_client/pkg', __dir__).freeze
-
-      def path
-        prefix = ''
-        linux_libc = ''
-        suffix = ''
-
-        arch, os = RUBY_PLATFORM.split('-')
-
-        arch =
-          case arch
-          when 'x86_64', 'amd64' then 'x86_64'
-          when 'aarch64', 'arm64' then 'aarch64'
-          else
-            raise "Unsupported architecture: #{arch}"
-          end
-
-        case os
-        when /darwin/
-          prefix = 'lib'
-          system = 'macos'
-          suffix = '.dylib'
-        when 'linux'
-          prefix = 'lib'
-          system = 'linux'
-          linux_libc = detect_libc
-          suffix = '.so'
-        when 'windows'
-          system = 'windows'
-          suffix = '.dll'
-        else
-          raise "Unsupported system: #{os}"
-        end
-
-        target_dir = "#{arch}-#{system}#{linux_libc}"
-        filename = "#{prefix}tb_client#{suffix}"
-
-        native_path = File.join(NATIVE_DIR, target_dir, filename)
-        return native_path if File.exist?(native_path)
-
-        pkg_path = File.join(PKG_DIR, target_dir, filename)
-        return pkg_path if File.exist?(pkg_path)
-
-        raise "tb_client library not found. Searched:\n  #{native_path}\n  #{pkg_path}"
-      end
-
-      private
-
-      def detect_libc
-        ldd_output = `ldd --version 2>&1 | head -n 1`.downcase
-
-        if ldd_output.include?('musl')
-          '-musl'
-        elsif ldd_output.include?('gnu') || ldd_output.include?('glibc')
-          '-gnu.2.27'
-        else
-          raise "Unsupported libc: #{ldd_output}"
-        end
-      end
-    end
-  end
-end

data/lib/tb_client.rb

@@ -1,282 +0,0 @@
-require 'ffi'
-require 'tb_client/shared_lib'
-
-module TBClient
-  extend FFI::Library
-
-  ffi_lib SharedLib.path
-
-  InitStatus = enum(FFI::Type::UINT8, [
-                    :SUCCESS, 0,
-                    :UNEXPECTED,
-                    :OUT_OF_MEMORY,
-                    :ADDRESS_INVALID,
-                    :ADDRESS_LIMIT_EXCEEDED,
-                    :SYSTEM_RESOURCES,
-                    :NETWORK_SUBSYSTEM])
-
-  ClientStatus = enum(FFI::Type::UINT8, [
-                      :OK, 0,
-                      :INVALID])
-
-  PacketStatus = enum(FFI::Type::UINT8, [
-                      :OK, 0,
-                      :TOO_MUCH_DATA,
-                      :CLIENT_EVICTED,
-                      :CLIENT_RELEASE_TOO_LOW,
-                      :CLIENT_RELEASE_TOO_HIGH,
-                      :CLIENT_SHUTDOWN,
-                      :INVALID_OPERATION,
-                      :INVALID_DATA_SIZE])
-
-  RegisterLogCallbackStatus = enum(FFI::Type::UINT8, [
-                                   :SUCCESS, 0,
-                                   :ALREADY_REGISTERED,
-                                   :NOT_REGISTERED])
-
-  Operation = enum(FFI::Type::UINT8, [
-                   :PULSE, 128,
-                   :GET_EVENTS, 137,
-                   :CREATE_ACCOUNTS, 138,
-                   :CREATE_TRANSFERS, 139,
-                   :LOOKUP_ACCOUNTS, 140,
-                   :LOOKUP_TRANSFERS, 141,
-                   :GET_ACCOUNT_TRANSFERS, 142,
-                   :GET_ACCOUNT_BALANCES, 143,
-                   :QUERY_ACCOUNTS, 144,
-                   :QUERY_TRANSFERS, 145])
-
-  CreateAccountResult = enum(FFI::Type::UINT32, [
-                             :OK, 0,
-                             :LINKED_EVENT_FAILED, 1,
-                             :LINKED_EVENT_CHAIN_OPEN, 2,
-                             :IMPORTED_EVENT_EXPECTED, 22,
-                             :IMPORTED_EVENT_NOT_EXPECTED, 23,
-                             :TIMESTAMP_MUST_BE_ZERO, 3,
-                             :IMPORTED_EVENT_TIMESTAMP_OUT_OF_RANGE, 24,
-                             :IMPORTED_EVENT_TIMESTAMP_MUST_NOT_ADVANCE, 25,
-                             :RESERVED_FIELD, 4,
-                             :RESERVED_FLAG, 5,
-                             :ID_MUST_NOT_BE_ZERO, 6,
-                             :ID_MUST_NOT_BE_INT_MAX, 7,
-                             :EXISTS_WITH_DIFFERENT_FLAGS, 15,
-                             :EXISTS_WITH_DIFFERENT_USER_DATA_128, 16,
-                             :EXISTS_WITH_DIFFERENT_USER_DATA_64, 17,
-                             :EXISTS_WITH_DIFFERENT_USER_DATA_32, 18,
-                             :EXISTS_WITH_DIFFERENT_LEDGER, 19,
-                             :EXISTS_WITH_DIFFERENT_CODE, 20,
-                             :EXISTS, 21,
-                             :FLAGS_ARE_MUTUALLY_EXCLUSIVE, 8,
-                             :DEBITS_PENDING_MUST_BE_ZERO, 9,
-                             :DEBITS_POSTED_MUST_BE_ZERO, 10,
-                             :CREDITS_PENDING_MUST_BE_ZERO, 11,
-                             :CREDITS_POSTED_MUST_BE_ZERO, 12,
-                             :LEDGER_MUST_NOT_BE_ZERO, 13,
-                             :CODE_MUST_NOT_BE_ZERO, 14,
-                             :IMPORTED_EVENT_TIMESTAMP_MUST_NOT_REGRESS, 26])
-
-  CreateTransferResult = enum(FFI::Type::UINT32, [
-                              :OK, 0,
-                              :LINKED_EVENT_FAILED, 1,
-                              :LINKED_EVENT_CHAIN_OPEN, 2,
-                              :IMPORTED_EVENT_EXPECTED, 56,
-                              :IMPORTED_EVENT_NOT_EXPECTED, 57,
-                              :TIMESTAMP_MUST_BE_ZERO, 3,
-                              :IMPORTED_EVENT_TIMESTAMP_OUT_OF_RANGE, 58,
-                              :IMPORTED_EVENT_TIMESTAMP_MUST_NOT_ADVANCE, 59,
-                              :RESERVED_FLAG, 4,
-                              :ID_MUST_NOT_BE_ZERO, 5,
-                              :ID_MUST_NOT_BE_INT_MAX, 6,
-                              :EXISTS_WITH_DIFFERENT_FLAGS, 36,
-                              :EXISTS_WITH_DIFFERENT_PENDING_ID, 40,
-                              :EXISTS_WITH_DIFFERENT_TIMEOUT, 44,
-                              :EXISTS_WITH_DIFFERENT_DEBIT_ACCOUNT_ID, 37,
-                              :EXISTS_WITH_DIFFERENT_CREDIT_ACCOUNT_ID, 38,
-                              :EXISTS_WITH_DIFFERENT_AMOUNT, 39,
-                              :EXISTS_WITH_DIFFERENT_USER_DATA_128, 41,
-                              :EXISTS_WITH_DIFFERENT_USER_DATA_64, 42,
-                              :EXISTS_WITH_DIFFERENT_USER_DATA_32, 43,
-                              :EXISTS_WITH_DIFFERENT_LEDGER, 67,
-                              :EXISTS_WITH_DIFFERENT_CODE, 45,
-                              :EXISTS, 46,
-                              :ID_ALREADY_FAILED, 68,
-                              :FLAGS_ARE_MUTUALLY_EXCLUSIVE, 7,
-                              :DEBIT_ACCOUNT_ID_MUST_NOT_BE_ZERO, 8,
-                              :DEBIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX, 9,
-                              :CREDIT_ACCOUNT_ID_MUST_NOT_BE_ZERO, 10,
-                              :CREDIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX, 11,
-                              :ACCOUNTS_MUST_BE_DIFFERENT, 12,
-                              :PENDING_ID_MUST_BE_ZERO, 13,
-                              :PENDING_ID_MUST_NOT_BE_ZERO, 14,
-                              :PENDING_ID_MUST_NOT_BE_INT_MAX, 15,
-                              :PENDING_ID_MUST_BE_DIFFERENT, 16,
-                              :TIMEOUT_RESERVED_FOR_PENDING_TRANSFER, 17,
-                              :CLOSING_TRANSFER_MUST_BE_PENDING, 64,
-                              :LEDGER_MUST_NOT_BE_ZERO, 19,
-                              :CODE_MUST_NOT_BE_ZERO, 20,
-                              :DEBIT_ACCOUNT_NOT_FOUND, 21,
-                              :CREDIT_ACCOUNT_NOT_FOUND, 22,
-                              :ACCOUNTS_MUST_HAVE_THE_SAME_LEDGER, 23,
-                              :TRANSFER_MUST_HAVE_THE_SAME_LEDGER_AS_ACCOUNTS, 24,
-                              :PENDING_TRANSFER_NOT_FOUND, 25,
-                              :PENDING_TRANSFER_NOT_PENDING, 26,
-                              :PENDING_TRANSFER_HAS_DIFFERENT_DEBIT_ACCOUNT_ID, 27,
-                              :PENDING_TRANSFER_HAS_DIFFERENT_CREDIT_ACCOUNT_ID, 28,
-                              :PENDING_TRANSFER_HAS_DIFFERENT_LEDGER, 29,
-                              :PENDING_TRANSFER_HAS_DIFFERENT_CODE, 30,
-                              :EXCEEDS_PENDING_TRANSFER_AMOUNT, 31,
-                              :PENDING_TRANSFER_HAS_DIFFERENT_AMOUNT, 32,
-                              :PENDING_TRANSFER_ALREADY_POSTED, 33,
-                              :PENDING_TRANSFER_ALREADY_VOIDED, 34,
-                              :PENDING_TRANSFER_EXPIRED, 35,
-                              :IMPORTED_EVENT_TIMESTAMP_MUST_NOT_REGRESS, 60,
-                              :IMPORTED_EVENT_TIMESTAMP_MUST_POSTDATE_DEBIT_ACCOUNT, 61,
-                              :IMPORTED_EVENT_TIMESTAMP_MUST_POSTDATE_CREDIT_ACCOUNT, 62,
-                              :IMPORTED_EVENT_TIMEOUT_MUST_BE_ZERO, 63,
-                              :DEBIT_ACCOUNT_ALREADY_CLOSED, 65,
-                              :CREDIT_ACCOUNT_ALREADY_CLOSED, 66,
-                              :OVERFLOWS_DEBITS_PENDING, 47,
-                              :OVERFLOWS_CREDITS_PENDING, 48,
-                              :OVERFLOWS_DEBITS_POSTED, 49,
-                              :OVERFLOWS_CREDITS_POSTED, 50,
-                              :OVERFLOWS_DEBITS, 51,
-                              :OVERFLOWS_CREDITS, 52,
-                              :OVERFLOWS_TIMEOUT, 53,
-                              :EXCEEDS_CREDITS, 54,
-                              :EXCEEDS_DEBITS, 55])
-
-  LogLevel = enum(FFI::Type::UINT8, [
-                  :ERR, 0,
-                  :WARN,
-                  :INFO,
-                  :DEBUG])
-
-  AccountFlags = bitmask(FFI::Type::UINT16, [
-    :LINKED,
-    :DEBITS_MUST_NOT_EXCEED_CREDITS,
-    :CREDITS_MUST_NOT_EXCEED_DEBITS,
-    :HISTORY,
-    :IMPORTED,
-    :CLOSED]
-  )
-
-  TransferFlags = bitmask(FFI::Type::UINT16, [
-    :LINKED,
-    :PENDING,
-    :POST_PENDING_TRANSFER,
-    :VOID_PENDING_TRANSFER,
-    :BALANCING_DEBIT,
-    :BALANCING_CREDIT,
-    :CLOSING_DEBIT,
-    :CLOSING_CREDIT,
-    :IMPORTED]
-  )
-
-  AccountFilterFlags = bitmask(FFI::Type::UINT32, [:DEBITS, :CREDITS, :REVERSED])
-
-  QueryFilterFlags = bitmask(FFI::Type::UINT32, [:REVERSED])
-
-  class Client < FFI::Struct
-    layout opaque: [:uint64, 4]
-  end
-
-  class UInt128 < FFI::Struct
-    layout low: :uint64,
-           high: :uint64
-  end
-
-  class Packet < FFI::Struct
-    layout user_data: :pointer,
-           data: :pointer,
-           data_size: :uint32,
-           user_tag: :uint16,
-           operation: Operation,
-           status: PacketStatus,
-           opaque: [:uint8, 64]
-  end
-
-  class Account < FFI::Struct
-    layout id: UInt128,
-           debits_pending: UInt128,
-           debits_posted: UInt128,
-           credits_pending: UInt128,
-           credits_posted: UInt128,
-           user_data_128: UInt128,
-           user_data_64: :uint64,
-           user_data_32: :uint32,
-           reserved: :uint32,
-           ledger: :uint32,
-           code: :uint16,
-           flags: AccountFlags,
-           timestamp: :uint64
-  end
-
-  class Transfer < FFI::Struct
-    layout id: UInt128,
-           debit_account_id: UInt128,
-           credit_account_id: UInt128,
-           amount: UInt128,
-           pending_id: UInt128,
-           user_data_128: UInt128,
-           user_data_64: :uint64,
-           user_data_32: :uint32,
-           timeout: :uint32,
-           ledger: :uint32,
-           code: :uint16,
-           flags: TransferFlags,
-           timestamp: :uint64
-  end
-
-  class CreateAccountsResult < FFI::Struct
-    layout index: :uint32,
-           result: CreateAccountResult
-  end
-
-  class CreateTransfersResult < FFI::Struct
-    layout index: :uint32,
-           result: CreateTransferResult
-  end
-
-  class AccountFilter < FFI::Struct
-    layout account_id: UInt128,
-           user_data_128: UInt128,
-           user_data_64: :uint64,
-           user_data_32: :uint32,
-           code: :uint16,
-           reserved: [:uint8, 58],
-           timestamp_min: :uint64,
-           timestamp_max: :uint64,
-           limit: :uint32,
-           flags: AccountFilterFlags
-  end
-
-  class QueryFilter < FFI::Struct
-    layout user_data_128: UInt128,
-           user_data_64: :uint64,
-           user_data_32: :uint32,
-           ledger: :uint32,
-           code: :uint16,
-           reserved: [:uint8, 6],
-           timestamp_min: :uint64,
-           timestamp_max: :uint64,
-           limit: :uint32,
-           flags: QueryFilterFlags
-  end
-
-  class AccountBalance < FFI::Struct
-    layout debits_pending: UInt128,
-           debits_posted: UInt128,
-           credits_pending: UInt128,
-           credits_posted: UInt128,
-           timestamp: :uint64,
-           reserved: [:uint8, 56]
-  end
-
-  callback :on_completion, [:uint, Packet.by_ref, :uint64, :pointer, :uint32], :void
-  callback :log_handler, [LogLevel, :pointer, :uint32], :void
-
-  attach_function :tb_client_init, [Client.by_ref, :pointer, :string, :uint32, :uint, :on_completion], InitStatus
-  attach_function :tb_client_submit, [Client.by_ref, Packet.by_ref], ClientStatus
-  attach_function :tb_client_deinit, [Client.by_ref], ClientStatus
-  attach_function :tb_client_register_log_callback, [:log_handler, :bool], RegisterLogCallbackStatus
-end

data/lib/tigerbeetle/account.rb

@@ -1,38 +0,0 @@
-module TigerBeetle
-  ACCOUNT_PARAMS = %i[
-    id debits_pending debits_posted credits_pending credits_posted user_data_128
-    user_data_64 user_data_32 ledger code flags timestamp
-  ]
-
-  Account = Struct.new(*ACCOUNT_PARAMS) do
-    def initialize(
-      id:,
-      debits_pending: 0,
-      debits_posted: 0,
-      credits_pending: 0,
-      credits_posted: 0,
-      user_data_128: 0,
-      user_data_64: 0,
-      user_data_32: 0,
-      ledger:,
-      code:,
-      flags: [],
-      timestamp: nil
-    )
-      super(
-        id,
-        debits_pending,
-        debits_posted,
-        credits_pending,
-        credits_posted,
-        user_data_128,
-        user_data_64,
-        user_data_32,
-        ledger,
-        code,
-        flags,
-        timestamp
-      )
-    end
-  end
-end

data/lib/tigerbeetle/account_balance.rb

@@ -1,23 +0,0 @@
-module TigerBeetle
-  ACCOUNT_BALANCE_PARAMS = %i[
-    debits_pending debits_posted credits_pending credits_posted timestamp
-  ]
-
-  AccountBalance = Struct.new(*ACCOUNT_BALANCE_PARAMS) do
-    def initialize(
-      debits_pending: 0,
-      debits_posted: 0,
-      credits_pending: 0,
-      credits_posted: 0,
-      timestamp: 0
-    )
-      super(
-        debits_pending,
-        debits_posted,
-        credits_pending,
-        credits_posted,
-        timestamp
-      )
-    end
-  end
-end

data/lib/tigerbeetle/account_filter.rb

@@ -1,31 +0,0 @@
-module TigerBeetle
-  ACCOUNT_FILTER_PARAMS = %i[
-    account_id user_data_128 user_data_64 user_data_32 code timestamp_min timestamp_max limit flags
-  ]
-
-  AccountFilter = Struct.new(*ACCOUNT_FILTER_PARAMS) do
-    def initialize(
-      account_id:,
-      user_data_128: 0,
-      user_data_64: 0,
-      user_data_32: 0,
-      code: 0,
-      timestamp_min: 0,
-      timestamp_max: 0,
-      limit:,
-      flags: []
-    )
-      super(
-        account_id,
-        user_data_128,
-        user_data_64,
-        user_data_32,
-        code,
-        timestamp_min,
-        timestamp_max,
-        limit,
-        flags
-      )
-    end
-  end
-end

data/lib/tigerbeetle/atomic_counter.rb

@@ -1,14 +0,0 @@
-module TigerBeetle
-  class AtomicCounter
-    attr_reader :value
-
-    def initialize(value = 0)
-      @value = value
-      @mutex = Mutex.new
-    end
-
-    def increment
-      @mutex.synchronize { @value += 1 }
-    end
-  end
-end

data/lib/tigerbeetle/client.rb

@@ -1,214 +0,0 @@
-require 'ffi'
-require 'tb_client'
-require 'tigerbeetle/converters'
-require 'tigerbeetle/account'
-require 'tigerbeetle/account_balance'
-require 'tigerbeetle/account_filter'
-require 'tigerbeetle/atomic_counter'
-require 'tigerbeetle/error'
-require 'tigerbeetle/query_filter'
-require 'tigerbeetle/request'
-require 'tigerbeetle/transfer'
-
-module TigerBeetle
-  class Client
-    def self.next_id
-      @counter ||= AtomicCounter.new
-      @counter.increment
-    end
-
-    def initialize(cluster_id = 0, address = '3000')
-      @inflight_requests = {}
-      # Keep a pointer to prevent proc from getting GCed
-      @callback = Proc.new { |*args| callback(*args) }
-      @client_id = self.class.next_id
-      @client = TBClient::Client.new
-
-      # FFI::MemoryPointer.new(:pointer, 1) # **void
-      cluster_id_ptr = serialize([cluster_id], Converters::UInt128)
-
-      status = TBClient.tb_client_init(
-        @client,
-        cluster_id_ptr,
-        address,
-        address.length,
-        @client_id,
-        &@callback
-      )
-      raise ClientError, "Unable to initialize native client: #{status}" unless status == :SUCCESS
-
-      # Make sure to deinitialize all clients when the process terminates
-      at_exit { deinit }
-    end
-
-    def logger=(logger)
-      @logger = logger
-      @log_callback = @logger ? Proc.new { |*args| log_callback(*args) } : nil
-
-      status = TBClient.tb_client_register_log_callback(@log_callback, true)
-      raise ClientError, "Unable to register logger: #{status}" unless status == :SUCCESS
-    end
-
-    def create_accounts(*accounts, &block)
-      submit_request(
-        :CREATE_ACCOUNTS,
-        accounts,
-        Converters::Account,
-        Converters::CreateAccountsResult,
-        &block
-      )
-    end
-
-    def create_transfers(*transfers, &block)
-      submit_request(
-        :CREATE_TRANSFERS,
-        transfers,
-        Converters::Transfer,
-        Converters::CreateTransfersResult,
-        &block
-      )
-    end
-
-    def lookup_accounts(*account_ids, &block)
-      submit_request(
-        :LOOKUP_ACCOUNTS,
-        account_ids,
-        Converters::UInt128,
-        Converters::Account,
-        &block
-      )
-    end
-
-    def lookup_transfers(*transfer_ids, &block)
-      submit_request(
-        :LOOKUP_TRANSFERS,
-        transfer_ids,
-        Converters::UInt128,
-        Converters::Transfer,
-        &block
-      )
-    end
-
-    def get_account_transfers(filter, &block)
-      submit_request(
-        :GET_ACCOUNT_TRANSFERS,
-        [filter],
-        Converters::AccountFilter,
-        Converters::Transfer,
-        &block
-      )
-    end
-
-    def get_account_balances(filter, &block)
-      submit_request(
-        :GET_ACCOUNT_BALANCES,
-        [filter],
-        Converters::AccountFilter,
-        Converters::AccountBalance,
-        &block
-      )
-    end
-
-    def query_accounts(filter, &block)
-      submit_request(
-        :QUERY_ACCOUNTS,
-        [filter],
-        Converters::QueryFilter,
-        Converters::Account,
-        &block
-      )
-    end
-
-    def query_transfers(filter, &block)
-      submit_request(
-        :QUERY_TRANSFERS,
-        [filter],
-        Converters::QueryFilter,
-        Converters::Transfer,
-        &block
-      )
-    end
-
-    def deinit
-      return unless client
-      return unless inflight_requests.empty?
-
-      TBClient.tb_client_deinit(client)
-      @client = nil
-    end
-
-    private
-
-    attr_reader :context, :client, :inflight_requests, :logger
-
-    def log_callback(level, ptr, length)
-      message = ptr.read_string(length).force_encoding('UTF-8')
-      case level
-      when :ERR then logger.error(message)
-      when :WARN then logger.warn(message)
-      when :INFO then logger.info(message)
-      when :DEBUG then logger.debug(message)
-      end
-    end
-
-    def callback(client_id, packet, timestamp, result_ptr, result_len)
-      request_id = packet[:user_data].read_uint64
-      request = inflight_requests.delete(request_id)
-      result = deserialize(result_ptr, request.converter, result_len)
-      request.block.call(result)
-    end
-
-    def submit_request(operation, request, request_converter, response_converter, &block)
-      raise ClientError, 'Client is not connected' unless client
-
-      request_id = self.class.next_id
-      user_data_ptr = FFI::MemoryPointer.new(:uint64, 1)
-      user_data_ptr.write_uint64(request_id)
-
-      data_ptr = serialize(request, request_converter)
-
-      packet = TBClient::Packet.new
-      packet[:user_data] = user_data_ptr
-      packet[:operation] = operation
-      packet[:status] = :OK
-      packet[:data_size] = data_ptr.size
-      packet[:data] = data_ptr
-
-      queue = Queue.new
-      inflight_requests[request_id] = Request.new(packet, response_converter) do |response|
-        if block
-          block.call(response)
-        else
-          queue << response
-        end
-      end
-
-      status = TBClient.tb_client_submit(client, packet)
-      raise ClientError, "Unable to submit request: #{status}" unless status == :OK
-
-      # block until the client return a response
-      queue.pop unless block
-    end
-
-    def serialize(data, converter)
-      data_ptr = FFI::MemoryPointer.new(converter.native_type, data.length, true)
-      data.each_with_index do |value, i|
-        # initialize type at the memory address and write value over it
-        converter.to_native(data_ptr[i], value)
-      end
-
-      data_ptr
-    end
-
-    def deserialize(ptr, converter, length)
-      type = converter.native_type
-      # copy data to own memory to retain it after tb_client has freed its memory
-      own_ptr = FFI::MemoryPointer.new(:char, type.size * length)
-      own_ptr.put_bytes(0, ptr.read_bytes(type.size * length))
-
-      Array.new(length / type.size) do |i|
-        converter.from_native(own_ptr + i * type.size)
-      end
-    end
-  end
-end