kafkr 0.5.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 839d5db49f24a6d283f12d213016c498834b12e90dcbb29a8e261100870be59f
+  data.tar.gz: b2700c8cb00ef4ea12207dc7323251a3e9ece950c60ccc17b9254ba3481763f7
+SHA512:
+  metadata.gz: c3b88b1c980c88d577d75d056f723b59f358829f5f231429d15bdf7e4db3487a00d777dfe63cd32e7b12b60742c1c3affb9087fddfafb5fb81f1917ea86bee1f
+  data.tar.gz: fb0971030fa3a95cda35423beef5a4da7dcfffaad41c9fa4f7c2081c09074eeadf2afc7ec90df0f4bcd29fb3120dced5702869c998f045ce3fd61f5becac6a00

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.6

data/README.md

@@ -0,0 +1,31 @@
+# Kafkr
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/kafkr`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/kafkr.

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/exe/kafkr

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+PORT = ENV["KAFKR_PORT"] || 4000
+
+begin
+  require "kafkr"
+rescue LoadError => e
+  puts "Failed to load Kafkr: #{e.message}"
+  exit(1)
+end
+
+begin
+  server = Kafkr::Log.new(PORT.to_i)
+  puts "Log started on port #{PORT}!"
+  server.start
+rescue => e
+  puts "An error occurred: #{e.message}"
+  exit(1)
+rescue Interrupt
+  puts "\nLog server shutting down gracefully..."
+  server.stop if server.respond_to?(:stop)
+  exit(0)
+end

data/exe/kafkr-consumer

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+
+require "kafkr"
+require "find"
+require "digest"
+
+# Accepting command line arguments for host and port
+host = ARGV[0] || "localhost"
+port = ARGV[1] || 4000
+
+puts "Running on host: #{host} and port: #{port}"
+
+$current_consumer = nil
+$restart_required = false
+$handlers_loaded = false
+$handlers_changed = false
+$loaded_handlers = {}
+
+Signal.trap("USR1") do
+  $restart_required = true
+end
+
+def stop_consumer
+  $current_consumer = nil if $current_consumer
+end
+
+def list_registered_handlers
+  puts "Registered Handlers:"
+  Kafkr::Consumer.handlers.each do |handler|
+    $loaded_handlers = {}
+    handler_name = handler.class.name.split("::").last.gsub(/Handler$/, "")
+    puts "#{handler_name} handler registered."
+  end
+end
+
+def start_consumer(port,host)
+  puts "Starting consumer on port #{port}!"
+  $handlers_changed = false
+
+  Kafkr::Consumer.configure do |config|
+    config.port = port
+    config.host = host
+  end
+
+  unless $handlers_loaded
+    Kafkr::Consumer.load_handlers if $handlers_changed == false
+    list_registered_handlers
+    $handlers_loaded = true
+  end
+
+  $current_consumer = Kafkr::Consumer.new
+  $current_consumer.listen do |message|
+    # Processing of the message
+  end
+end
+
+def reload_handlers(file_checksums)
+  handlers_before_reload = Kafkr::Consumer.handlers.dup # Store current handlers
+  Find.find(Kafkr::Consumer::HANDLERS_DIRECTORY) do |path|
+    next unless File.file?(path)
+    load path
+  end
+
+  if $handlers_changed
+    Kafkr::Consumer.load_handlers
+    new_handlers = Kafkr::Consumer.handlers - handlers_before_reload
+    if new_handlers.any?
+      new_handlers.each do |handler|
+        handler_name = handler.class.name.split("::").last.gsub(/Handler$/, "").capitalize
+        puts "#{handler_name} handler updated - ok!"
+      end
+    end
+  end
+end
+
+def monitor_handlers(file_checksums)
+  loop do
+    changed = false
+    Find.find(Kafkr::Consumer::HANDLERS_DIRECTORY) do |path|
+      next unless File.file?(path)
+
+      current_checksum = Digest::MD5.file(path).hexdigest
+      if file_checksums[path] != current_checksum
+        file_checksums[path] = current_checksum
+        changed = true
+      end
+    end
+
+    $handlers_changed = changed # Set outside the loop
+
+    reload_handlers(file_checksums) if $handlers_changed
+    sleep 5
+  end
+end
+
+file_checksums = {}
+monitoring_thread = Thread.new { monitor_handlers(file_checksums) }
+start_consumer(port,host)  # Pass the port here
+
+begin
+  loop do
+    if $restart_required
+      stop_consumer
+      start_consumer(port,host)
+      $restart_required = false
+    end
+    sleep 1
+  end
+rescue LoadError => e
+  exit(1)
+rescue => e
+  exit(1)
+rescue Interrupt
+  stop_consumer
+  exit(0)
+ensure
+  monitoring_thread.kill if monitoring_thread
+end

data/exe/kafkr-keys

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require "openssl"
+require "base64"
+
+key = OpenSSL::Random.random_bytes(32)
+encoded_key = Base64.encode64(key).chomp # .chomp to remove newline character from encoded key
+
+puts "keys: #{encoded_key}"

data/exe/kafkr-producer

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'readline'
+
+# Parsing command line arguments for host and port
+host = ARGV[0] || "localhost"
+port = ARGV[1] || 4000
+
+puts "Running on host: #{host} and port: #{port}"
+
+begin
+  require "kafkr"
+rescue LoadError => e
+  puts "Failed to load Kafkr: #{e.message}"
+  exit(1)
+end
+
+begin
+  Kafkr::Producer.configure do |config|
+    config.host = host
+    config.port = port
+  end
+
+  while line = Readline.readline("> ", true)
+    break if line == "exit"
+
+    if line.include? "<=>"
+      puts Kafkr::Producer.send_message_and_wait(line)
+    else
+      Kafkr::Producer.send_message(line)
+    end
+  end
+rescue => e
+  puts "An error occurred: #{e.message}"
+  exit(1)
+rescue Interrupt
+  puts "\nProducer server shutting down gracefully..."
+  exit(0)
+end

data/handlers/web_handler.rb

@@ -0,0 +1,12 @@
+class WebHandler < Kafkr::Consumer::Handler
+  def handle?(message)
+    can_handle? message, "web"
+  end
+
+  def handle(message)
+    puts message
+    if message["sync"]
+      reply to: message, payload: {test: "set"}
+    end
+  end
+end

data/lib/kafkr/consumer.rb

@@ -0,0 +1,278 @@
+require "socket"
+require "timeout"
+require "ostruct"
+require "fileutils"
+require "json"
+
+module Kafkr
+  class LostConnection < StandardError; end
+
+  class Consumer
+    @handlers = []
+
+    HANDLERS_DIRECTORY = "./handlers"
+
+    class << self
+      attr_reader :handlers
+
+      def configuration
+        FileUtils.mkdir_p "./.kafkr"
+        @configuration ||= OpenStruct.new
+        @configuration
+      end
+
+      def configure
+        yield(configuration) if block_given?
+      end
+
+      def register_handler(handler)
+        @handlers << handler
+      end
+
+      $loaded_handlers = {}
+      $handlers_changed = true
+
+      def list_registered_handlers
+        puts "Registered handlers:"
+        $loaded_handlers.keys.each { |handler| puts "- #{handler}" }
+      end
+
+      def load_handlers(directory = "./handlers")
+        # Load handlers and check for new additions
+        Dir.glob("#{directory}/*.rb").each do |file|
+          handler_name = File.basename(file, ".rb")
+          unless $loaded_handlers[handler_name]
+            require file
+            $loaded_handlers[handler_name] = true
+            $handlers_changed = true
+          end
+        end
+
+        # Display handlers if there are changes
+        if $handlers_changed
+          $handlers_changed = false
+        end
+      end
+    end
+
+    class Handler
+      def handle?(message)
+        raise NotImplementedError, "You must implement the handle? method"
+      end
+
+      def handle(message)
+        raise NotImplementedError, "You must implement the handle method"
+      end
+
+      # ... rest of your existing Handler methods ...
+      def self.inherited(subclass)
+        Consumer.register_handler(subclass.new)
+      end
+
+      protected
+
+      def reply to:, payload:
+        
+        Kafkr::Producer.configure do |config|
+          config.host = Consumer.configuration.host
+          config.port = Consumer.configuration.port
+        end
+
+        Kafkr::Producer.send_message({reply: {payload: payload, uuid: to['sync_uid']}},acknowledge: false)
+      end
+
+      private
+
+      def can_handle?(message, name, ignore: :any)
+        if message.is_a?(Numeric)
+          return true if message == name.to_i
+        elsif ignore == :hash
+          return true if message[:message] && message[:message][:body] && message[:message][:body] == name
+          return true if message[:message] && message[:message][:body] && message[:message][:body].start_with?(name)
+        elsif ignore == :string
+          return true if message.key? name
+        else
+          return true if message.key? name
+          return true if message[:message] && message[:message][:body] && message[:message][:body] == name
+          return true if message[:message] && message[:message][:body] && message[:message][:body].start_with?(name)
+        end
+        false
+      end
+    end
+
+    def initialize(host = Consumer.configuration.host, port = Consumer.configuration.port)
+      @host = host
+      @port = port
+    end
+
+    def fibonacci(n)
+      (n <= 1) ? n : fibonacci(n - 1) + fibonacci(n - 2)
+    end
+
+    def backoff_time(attempt)
+      [fibonacci(attempt), fibonacci(5)].min
+    end
+
+    def valid_class_name?(name)
+      # A valid class name starts with an uppercase letter and
+      # followed by zero or more letters, numbers, or underscores.
+      /^[A-Z]\w*$/.match?(name)
+    end
+
+    # sugests a working handler
+    def print_handler_class(name)
+      return if name.is_a?(Numeric)
+
+      # If name is a Hash, use its first key
+      name = name.keys.first if name.is_a?(Hash)
+
+      # Generate the handler name based on the naming convention
+      handler_name = "#{name.downcase}_handler"
+
+      # Check if the handler is already loaded
+      if $loaded_handlers.key?(handler_name)
+        return
+      end
+
+      if valid_class_name? name.capitalize
+        puts "No handler for this message, you could use this one."
+        puts ""
+
+        handler_class_string = <<~HANDLER_CLASS
+
+          class #{name.capitalize}Handler < Kafkr::Consumer::Handler
+            def handle?(message)
+              can_handle? message, '#{name}'
+            end
+      
+            def handle(message)
+              puts message
+            end
+          end
+
+          save the file to ./handlers/#{name}_handler.rb
+
+        HANDLER_CLASS
+
+        puts handler_class_string
+      end
+    end
+
+    require "timeout"
+
+    def listen_for(message, send_message)
+      attempt = 0
+      begin
+        socket = TCPSocket.new( Consumer.configuration.host,  Consumer.configuration.port)
+        puts "Connected to server. #{Consumer.configuration.host} #{Consumer.configuration.port} " if attempt == 0
+        attempt = 0
+
+        Timeout.timeout(20) do
+          # Call the provided send_message method or lambda, passing the message as an argument
+          sync_uid = send_message.call(message, acknowledge: false)
+
+          loop do
+            received_message = socket.gets
+            raise LostConnection if received_message.nil?
+            # Assuming Kafkr::Encryptor is defined elsewhere
+            received_message = Kafkr::Encryptor.new.decrypt(received_message.chomp)            
+            # Yield every received message to the given block
+            if valid_json?(received_message)
+               payload =yield JSON.parse(received_message),sync_uid if block_given?
+               return payload if payload
+            end
+          end
+        end
+      rescue Timeout::Error
+        puts "Listening timed out after 20 seconds."
+        socket&.close
+      rescue LostConnection
+        attempt += 1
+        wait_time = backoff_time(attempt)
+        puts "Connection lost. Reconnecting in #{wait_time} seconds..."
+        sleep(wait_time)
+      rescue Errno::ECONNREFUSED, Timeout::Error
+        attempt += 1
+        wait_time = backoff_time(attempt)
+        puts "Failed to connect on attempt #{attempt}. Retrying in #{wait_time} seconds..."
+        sleep(wait_time)
+      rescue Interrupt
+        puts "Received interrupt signal. Shutting down consumer gracefully..."
+        socket&.close
+        exit(0)
+      end
+    end
+
+    def listen
+      attempt = 0
+      loop do
+        socket = TCPSocket.new(Consumer.configuration.host,  Consumer.configuration.port)
+        puts "Connected to server. #{Consumer.configuration.host} #{Consumer.configuration.port} " if attempt == 0
+        attempt = 0
+
+        loop do
+          message = socket.gets
+          raise LostConnection if message.nil?
+
+          # Assuming Kafkr::Encryptor is defined elsewhere
+          message = Kafkr::Encryptor.new.decrypt(message.chomp)
+          if valid_json?(message)
+            dispatch_to_handlers(JSON.parse(message)) do |message|
+              yield message if block_given?
+            end
+          else
+            dispatch_to_handlers(message) do |message|
+              yield message if block_given?
+            end
+          end
+        end
+      rescue LostConnection
+        attempt += 1
+        wait_time = backoff_time(attempt)
+        puts "Connection lost. Reconnecting in #{wait_time} seconds..."
+        sleep(wait_time)
+      rescue Errno::ECONNREFUSED, Timeout::Error
+        attempt += 1
+        wait_time = backoff_time(attempt)
+        puts "Failed to connect on attempt #{attempt}. Retrying in #{wait_time} seconds..."
+        sleep(wait_time)
+      rescue Interrupt
+        puts "Received interrupt signal. Shutting down consumer gracefully..."
+        socket&.close
+        exit(0)
+      end
+    end
+
+    def valid_json?(json)
+      JSON.parse(json)
+      true
+    rescue JSON::ParserError
+      false
+    end
+
+    alias_method :consume, :listen
+    alias_method :receive, :listen
+    alias_method :connect, :listen
+    alias_method :monitor, :listen
+    alias_method :observe, :listen
+
+    private
+
+    def dispatch_to_handlers(message)
+      message_hash = message.is_a?(String) ? {message: {body: message}} : message
+
+      self.class.handlers.each do |handler|
+        if handler.handle?(message_hash)
+          handler.handle(message_hash)
+        end
+      end
+
+      print_handler_class(message)
+
+      yield message_hash if block_given?
+    end
+  end
+
+  # Assuming the handlers directory is the default location
+  Consumer.load_handlers
+end

data/lib/kafkr/encryptor.rb

@@ -0,0 +1,34 @@
+require "openssl"
+require "base64"
+
+module Kafkr
+  class Encryptor
+    ALGORITHM = "aes-256-cbc"
+
+    def initialize
+      @key = Base64.decode64("2wZ85yxQe0lmiQ5nsqdmPWoGB0W6HZW8S/UXVTLQ6WY=")
+    end
+
+    def encrypt(data)
+      cipher = OpenSSL::Cipher.new(ALGORITHM)
+      cipher.encrypt
+      cipher.key = @key
+      iv = cipher.random_iv
+      encrypted_data = cipher.update(data) + cipher.final
+      encrypted_data = Base64.strict_encode64(iv + encrypted_data)
+    end
+
+    def decrypt(encrypted_data)
+      # puts "Encrypted data before decoding: #{encrypted_data.inspect}"
+      decipher = OpenSSL::Cipher.new(ALGORITHM)
+      decipher.decrypt
+      decipher.key = @key
+      raw_data = Base64.strict_decode64(encrypted_data)
+      decipher.iv = raw_data[0, decipher.iv_len]
+      decipher.update(raw_data[decipher.iv_len..-1]) + decipher.final
+    rescue OpenSSL::Cipher::CipherError => e
+      puts "Decryption failed: #{e.message}"
+      nil
+    end
+  end
+end

data/lib/kafkr/log.rb

@@ -0,0 +1,118 @@
+require "socket"
+require "rubygems"
+
+module Kafkr
+  class Log
+    def initialize(port)
+      @server = TCPServer.new(port)
+      @received_file = "./.kafkr/log.txt"
+      @broker = MessageBroker.new
+      @whitelist = load_whitelist
+      @acknowledged_message_ids = load_acknowledged_message_ids
+    end
+
+    def load_acknowledged_message_ids
+      unless File.exist?("./.kafkr/acknowledged_message_ids.txt")
+        `mkdir -p ./.kafkr`
+        `touch ./.kafkr/acknowledged_message_ids.txt`
+      end
+
+      config_path = File.expand_path("./.kafkr/acknowledged_message_ids.txt")
+      return [] unless File.exist?(config_path)
+
+      File.readlines(config_path).map(&:strip)
+    rescue Errno::ENOENT, Errno::EACCES => e
+      puts "Error loading acknowledged_message_ids: #{e.message}"
+      []
+    end
+
+    def start
+      loop do
+        client = @server.accept
+        client_ip = client.peeraddr[3]
+
+        unless whitelisted?(client_ip)
+          puts "Connection from non-whitelisted IP: #{client_ip}. Ignored."
+          client.close
+          next
+        end
+
+        @broker.add_subscriber(client)
+
+        Thread.new do
+          loop do
+            encrypted_message = client.gets
+            if encrypted_message.nil?
+              @broker.last_sent.delete(client)
+              client.close
+              @broker.subscribers.delete(client)
+              puts "Client connection closed. Removed from subscribers list."
+              break
+            else
+              decryptor = Kafkr::Encryptor.new
+              message = decryptor.decrypt(encrypted_message.chomp) # Decrypt the message here
+              uuid, message_content = extract_uuid(message)
+              if uuid && message_content
+                if @acknowledged_message_ids.include?(uuid)
+                  acknowledge_existing_message(uuid, client)
+                else
+                  acknowledge_message(uuid, client)
+                  persist_received_message(uuid)
+                  @acknowledged_message_ids << uuid
+                  @broker.broadcast(message_content)
+                end
+              else
+                puts "Received invalid message format: #{message}"
+              end
+            end
+          rescue Errno::ECONNRESET
+            puts "Connection reset by client. Closing connection..."
+            client.close
+          end
+        end
+      end
+    end
+
+    def load_whitelist
+      whitelist = ["localhost", "::1","127.0.0.1"]
+      if File.exist?("whitelist.txt")
+        File.readlines("whitelist.txt").each do |line|
+          ip = line.strip.sub(/^::ffff:/, "")
+          whitelist << ip
+        end
+      end
+      whitelist
+    end
+
+    def whitelisted?(ip)
+      @whitelist.include?(ip.gsub("::ffff:", ""))
+    end
+
+    private
+
+    def extract_uuid(message)
+      match_data = /^(\w{8}-\w{4}-\w{4}-\w{4}-\w{12}): (.+)$/.match(message)
+      match_data ? [match_data[1], match_data[2]] : [nil, nil]
+    end
+
+    def acknowledge_message(uuid, client)
+      puts "Received message with UUID #{uuid}. Acknowledged."
+      acknowledgment_message = "ACK: #{uuid}"
+      client.puts(acknowledgment_message)
+      puts "Acknowledgment sent to producer: #{acknowledgment_message}"
+    end
+
+    def acknowledge_existing_message(uuid, client)
+      puts "Received duplicate message with UUID #{uuid}. Already Acknowledged."
+      acknowledgment_message = "ACK-DUPLICATE: #{uuid}"
+      client.puts(acknowledgment_message)
+      puts "Duplicate acknowledgment sent to producer: #{acknowledgment_message}"
+    end
+
+    def persist_received_message(uuid)
+      File.open("./.kafkr/acknowledged_message_ids.txt", "a") do |file|
+        file.puts(uuid)
+      end
+    end
+  end
+end

data/lib/kafkr/message_broker.rb

@@ -0,0 +1,33 @@
+module Kafkr
+  class MessageBroker
+    attr_accessor :last_sent, :subscribers
+
+    def initialize
+      @subscribers = []
+      @last_sent = {}
+    end
+
+    def add_subscriber(socket)
+      @subscribers << socket
+      @last_sent[socket] = nil
+    end
+
+    def broadcast(message)
+      Kafkr.log message
+
+      encrypted_message = Kafkr::Encryptor.new.encrypt(message)
+
+      @subscribers.each do |subscriber|
+        if !subscriber.closed?
+          subscriber.puts(encrypted_message)
+          @last_sent[subscriber] = encrypted_message
+        end
+      rescue Errno::EPIPE
+        # Optionally, handle broken pipe error
+      rescue IOError
+        @subscribers.delete(subscriber)
+        @last_sent.delete(subscriber)
+      end
+    end
+  end
+end

data/lib/kafkr/producer.rb

@@ -0,0 +1,200 @@
+require "readline"
+require "socket"
+require "fileutils"
+require "securerandom"
+require "ostruct"
+require "json"
+require "fiber"
+module Kafkr
+  module Producer
+    @@file_mutex = Mutex.new
+
+    MESSAGE_QUEUE = "./.kafkr/message_queue.txt"
+    ACKNOWLEDGED_MESSAGE_QUEUE = "./.kafkr/acknowledged_messages.txt"
+
+    def self.configuration
+      FileUtils.mkdir_p "./.kafkr"
+      @configuration ||= OpenStruct.new
+      @configuration.queue_file = MESSAGE_QUEUE
+      @configuration.acknowledged_file = ACKNOWLEDGED_MESSAGE_QUEUE
+      @configuration.message_queue = []
+      @configuration.acknowledged_messages = load_acknowledged_messages
+      load_queue_from_file
+      @configuration
+    end
+
+    def self.configure
+      yield(configuration)
+    rescue => e
+      logger.error("Configuration error: #{e.message}")
+    end
+
+    def self.structured_data_to_hash(input:, sync_uid:)
+      # Check the overall structure with regex and make quotes optional
+      unless /\A\w+\s*(=>|<=>)\s*((\w+:\s*['"]?[^'",]*['"]?,\s*)*(\w+:\s*['"]?[^'",]*['"]?)\s*)\z/.match?(input)
+        return input
+      end
+
+      if input.include?("<=>")
+        # puts "sync message"
+        # Extract the type and key-value pairs
+        type, key_values_str = input.split("<=>").map(&:strip)
+
+        # puts type
+        # puts key_values_str
+
+        key_values = key_values_str.scan(/(\w+):\s*['"]?([^'",]*)['"]?/)
+
+        # Convert the array of pairs into a hash, stripping quotes if they exist
+        hash_body = key_values.to_h do |key, value|
+          [key.to_sym, value.strip.gsub(/\A['"]|['"]\z/, "")]
+        end
+
+        # Return the final hash with the type as the key
+        {type.to_sym => hash_body, :sync => true, :sync_uid => sync_uid}
+
+      else
+        # puts "async message"
+        # Extract the type and key-value pairs
+        type, key_values_str = input.split("=>").map(&:strip)
+        key_values = key_values_str.scan(/(\w+):\s*['"]?([^'",]*)['"]?/)
+
+        # Convert the array of pairs into a hash, stripping quotes if they exist
+        hash_body = key_values.to_h do |key, value|
+          [key.to_sym, value.strip.gsub(/\A['"]|['"]\z/, "")]
+        end
+
+        # Return the final hash with the type as the key
+        {type.to_sym => hash_body}
+      end
+    end
+
+    def self.send_message(message, acknowledge: true)
+      uuid = SecureRandom.uuid
+
+      if message.is_a? String
+        message = structured_data_to_hash(input: message, sync_uid: uuid)
+        message_with_uuid = "#{uuid}: #{message}"
+      end
+
+      if message.is_a?(Hash)
+        message_with_uuid = "#{uuid}: #{JSON.generate(message)}"
+      end
+
+      # Encrypt the message here
+      encrypted_message_with_uuid = Kafkr::Encryptor.new.encrypt(message_with_uuid)
+
+      begin
+        if acknowledge
+          if !@configuration.acknowledged_messages.include?(uuid)
+            socket = TCPSocket.new(@configuration.host, @configuration.port)
+            listen_for_acknowledgments(socket) if acknowledge
+            send_queued_messages(socket)
+            # Send the encrypted message instead of the plain one
+            socket.puts(encrypted_message_with_uuid)
+          else
+            puts "Message with UUID #{uuid} has already been acknowledged. Skipping."
+          end
+        else
+          socket = TCPSocket.new(@configuration.host, @configuration.port)
+          send_queued_messages(socket)
+          socket.puts(encrypted_message_with_uuid)
+        end
+      rescue Errno::ECONNREFUSED
+        puts "Connection refused. Queuing message: #{encrypted_message_with_uuid}"
+        # Queue the encrypted message
+        @configuration.message_queue.push(encrypted_message_with_uuid)
+        save_queue_to_file
+      rescue Errno::EPIPE
+        puts "Broken pipe error. Retrying connection..."
+        retry_connection(encrypted_message_with_uuid)
+      end
+
+      uuid
+    end
+
+    def self.send_message_and_wait(message)
+      # Using method(:send_message) to pass the send_message method as a callable object
+      
+      payload = Consumer.new.listen_for(message, self.method(:send_message)) do |received_message,sync_uid|
+        if received_message.key? "reply"
+          if received_message["reply"].dig('uuid') == sync_uid
+            received_message["reply"].dig('payload')
+          end
+        end
+
+      end
+
+      payload
+    end
+
+    private
+
+    def self.listen_for_acknowledgments(socket)
+      Thread.new do
+        while line = socket.gets
+          line = line.chomp
+          if line.start_with?("ACK:")
+            uuid = line.split(" ")[1]
+            handle_acknowledgment(uuid)
+          end
+        end
+      end
+    end
+
+    def self.handle_acknowledgment(uuid)
+      @configuration.acknowledged_messages << uuid
+      save_acknowledged_messages
+    end
+
+    def self.retry_connection(message_with_uuid)
+      sleep(5)
+      send_message(message_with_uuid)
+    end
+
+    def self.send_queued_messages(socket)
+      until @configuration.message_queue.empty?
+        queued_message = @configuration.message_queue.shift
+        socket.puts(queued_message)
+      end
+    end
+
+    def self.save_queue_to_file
+      @@file_mutex.synchronize do
+        File.open(@configuration.queue_file, "w") do |file|
+          file.puts(@configuration.message_queue)
+        end
+      end
+    end
+
+    def self.load_queue_from_file
+      @@file_mutex.synchronize do
+        if File.exist?(@configuration.queue_file)
+          @configuration.message_queue = File.readlines(@configuration.queue_file).map(&:chomp)
+        end
+      end
+    end
+
+    def self.load_acknowledged_messages
+      @@file_mutex.synchronize do
+        if File.exist?(@configuration.acknowledged_file)
+          File.readlines(@configuration.acknowledged_file).map(&:chomp)
+        else
+          []
+        end
+      end
+    end
+
+    def self.save_acknowledged_messages
+      @@file_mutex.synchronize do
+        File.open(@configuration.acknowledged_file, "w") do |file|
+          file.puts(@configuration.acknowledged_messages)
+        end
+      end
+    end
+
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+end

data/lib/kafkr/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kafkr
+  VERSION = "0.5.5"
+end

data/lib/kafkr.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "logger"
+require "openssl"
+require "securerandom"
+require "ostruct"
+require "gibberish"
+
+require_relative "kafkr/encryptor"
+require_relative "kafkr/message_broker"
+require_relative "kafkr/log"
+require_relative "kafkr/consumer"
+require_relative "kafkr/producer"
+
+module Kafkr
+  class << self
+    attr_accessor :current_environment
+    def logger
+      @logger ||= configure_logger
+    end
+
+    def configure_logger(output = default_output)
+      begin
+        @logger = ::Logger.new(output)
+      rescue Errno::EACCES, Errno::ENOENT => e
+        @logger = ::Logger.new(STDOUT)
+        @logger.error("Could not open log file: #{e.message}")
+      end
+      set_logger_level
+      @logger
+    end
+
+    def default_output
+      case current_environment
+      when "production"
+        "/var/log/kafkr.log"
+      else
+        STDOUT
+      end
+    end
+
+    def set_logger_level
+      @logger.level = case current_environment
+      when "development"
+        ::Logger::DEBUG
+      when "staging"
+        ::Logger::INFO
+      when "production"
+        ::Logger::WARN
+      else
+        ::Logger::DEBUG
+      end
+    end
+
+    def current_environment
+      @current_environment ||= ENV["KAFKR_ENV"] || "development"
+    end
+
+    def development?
+      current_environment == "development"
+    end
+
+    def test?
+      current_environment == "test"
+    end
+
+    def staging?
+      current_environment == "staging"
+    end
+
+    def production?
+      current_environment == "production"
+    end
+
+    def write(message, unique_id = nil)
+      begin
+        unique_id ||= SecureRandom.uuid
+      rescue => e
+        unique_id = "unknown"
+        @logger.error("Failed to generate UUID: #{e.message}")
+      end
+      formatted_message = "[#{unique_id}] #{message}"
+
+      begin
+        puts formatted_message if development?
+        logger.info(formatted_message)
+      rescue IOError => e
+        @logger.error("Failed to write log: #{e.message}")
+      end
+    end
+
+    alias_method :log, :write
+    alias_method :output, :write
+    alias_method :info, :write
+    alias_method :record, :write
+    alias_method :trace, :write
+  end
+
+  class Error < StandardError; end
+
+  def self.configuration
+    @configuration ||= OpenStruct.new
+  end
+
+  def self.configure
+    yield(configuration)
+  rescue => e
+    logger.error("Configuration error: #{e.message}")
+  end
+end

data/sig/kafkr.rbs

@@ -0,0 +1,4 @@
+module Kafkr
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: kafkr
+version: !ruby/object:Gem::Version
+  version: 0.5.5
+platform: ruby
+authors:
+- Delaney Kuldvee Burke
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gibberish
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: A homage to kafkr implmented in ruby
+email:
+- delaney@zero2one.ee
+executables:
+- kafkr
+- kafkr-consumer
+- kafkr-keys
+- kafkr-producer
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- README.md
+- Rakefile
+- exe/kafkr
+- exe/kafkr-consumer
+- exe/kafkr-keys
+- exe/kafkr-producer
+- handlers/web_handler.rb
+- lib/kafkr.rb
+- lib/kafkr/consumer.rb
+- lib/kafkr/encryptor.rb
+- lib/kafkr/log.rb
+- lib/kafkr/message_broker.rb
+- lib/kafkr/producer.rb
+- lib/kafkr/version.rb
+- sig/kafkr.rbs
+homepage: https://zero2one.ee/gems/kafkr
+licenses: []
+metadata:
+  homepage_uri: https://zero2one.ee/gems/kafkr
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.21
+signing_key:
+specification_version: 4
+summary: A homage to kafkr implmented in ruby
+test_files: []