kafkr 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c15f14feed8ee398816eb4454850798f764f10cafdf12f27aca353ac2412fa1b
-  data.tar.gz: 77c4facf9f2290d087d2b5b40aa63714e0c01f5d0f4a33cce4c85349264dfe63
+  metadata.gz: 3a404654568d9f0c4a16e16f2341757b231cefd27e02186a4de5e34e945afe07
+  data.tar.gz: 3acf9756a6d8ff3f372d595171cb967736430768c6181b7aca9e79f44061bc8f
 SHA512:
-  metadata.gz: 3e1089f1fbe70c98be8c9ec09fe9d9967c20594c120857fa486bde44bb3ab2ef32cb02df7ae485e383ac1d802243a9468019bf9e6bfd6e057ce57fe14e465e4a
-  data.tar.gz: e929ce1c00207dd3f63be0294f73d4b885a3786a0748e84650baedd3a01e22e9755de5acf85d111d8e0ea29ce0ba1d4e51906f5a5228c0b5b2acbb3de56857a8
+  metadata.gz: b7ca82215482129450e112709ed46533be1638d525b433d92d571b188f93d01c787be4a4eb31cad4509d7c96df23850795bf77171972178491c2ed850868a2e0
+  data.tar.gz: 7bb54ca0f2ac1fdd3a4db32c12f8e90bc70dfd272007b9b17204a177d488788f5c3c4430a2f12920e07c614f92deac0cd8d3b4a007ee4fc12253dea4b0efe447

data/lib/kafkr/consumer.rb

@@ -39,7 +39,6 @@ module Kafkr
       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]
@@ -48,11 +47,6 @@ module Kafkr
             $handlers_changed = true
           end
         end
-
-        # Display handlers if there are changes
-        if $handlers_changed
-          $handlers_changed = false
-        end
       end
     end
 
@@ -65,20 +59,19 @@ module Kafkr
         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:
+      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)
+        Kafkr::Producer.send_message({reply: {payload: payload, uuid: to["sync_uid"]}})
       end
 
       private
@@ -114,45 +107,34 @@ module Kafkr
     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 Kafkr::Consumer.configuration.suggest_handlers
-        if valid_class_name? name.capitalize
-          puts "No handler for this message, you could use this one."
-          puts ""
+        if valid_class_name?(name.capitalize)
+          puts "No handler for this message, you could use this one.\n\n"
 
           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
-
+            # Save the file to ./handlers/#{name}_handler.rb
           HANDLER_CLASS
 
           puts handler_class_string
@@ -165,38 +147,28 @@ module Kafkr
     def listen_for(message, send_message)
       attempt = 0
       begin
-        socket = TCPSocket.new(Consumer.configuration.host, Consumer.configuration.port)
+        socket = TCPSocket.new(@host, @port)
         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)
+          sync_uid = send_message.call(message)
 
           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
+      rescue Timeout::Error, LostConnection, Errno::ECONNREFUSED
         attempt += 1
         wait_time = backoff_time(attempt)
-        puts "Failed to connect on attempt #{attempt}. Retrying in #{wait_time} seconds..."
+        puts "Attempt #{attempt}: Retrying in #{wait_time} seconds..."
         sleep(wait_time)
+        retry
       rescue Interrupt
         puts "Received interrupt signal. Shutting down consumer gracefully..."
         socket&.close
@@ -207,39 +179,9 @@ module Kafkr
     def listen
       attempt = 0
       loop do
-        socket = TCPSocket.new(Consumer.configuration.host, Consumer.configuration.port)
-        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
+        listen_for("dummy", ->(msg) { puts "Listening..." }) do |message|
+          puts "Received message: #{message}"
         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
 
@@ -273,6 +215,5 @@ module Kafkr
     end
   end
 
-  # Assuming the handlers directory is the default location
   Consumer.load_handlers
 end

data/lib/kafkr/encryptor.rb

@@ -6,7 +6,7 @@ module Kafkr
     ALGORITHM = "aes-256-cbc"
 
     def initialize
-      @key = Base64.decode64("2wZ85yxQe0lmiQ5nsqdmPWoGB0W6HZW8S/UXVTLQ6WY=")
+      @key = Base64.decode64(ENV["KAFKR_ENCRYPTION_KEY"])
     end
 
     def encrypt(data)

data/lib/kafkr/log.rb

@@ -8,22 +8,17 @@ module Kafkr
       @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`
+    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
-
-      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}"
-      []
+      whitelist
     end
 
     def start
@@ -53,14 +48,7 @@ module Kafkr
               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
+                @broker.broadcast(message_content)
               else
                 puts "Received invalid message format: #{message}"
               end
@@ -73,17 +61,6 @@ module Kafkr
       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
@@ -91,39 +68,15 @@ module Kafkr
     private
 
     def extract_uuid(message)
-
-      #check if message if valid json
+      # Check if message is valid JSON
       begin
         message = JSON.parse(message)
-        
         return message["uuid"], message
-
       rescue JSON::ParserError => e
         puts "Received invalid message format: #{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
-      
-    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/producer.rb

@@ -10,16 +10,12 @@ module Kafkr
     @@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 = []
-      @configuration.acknowledged_messages = load_acknowledged_messages
       load_queue_from_file
       @configuration.is_json = false
       @configuration
@@ -32,48 +28,29 @@ module Kafkr
     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)
+    def self.send_message(message)
       uuid = SecureRandom.uuid
-    
       message_with_uuid = nil
 
       if Kafkr::Producer.configuration.is_json
@@ -91,28 +68,14 @@ module Kafkr
         end
       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
+        socket = TCPSocket.new(@configuration.host, @configuration.port)
+        send_queued_messages(socket)
+        socket.puts(encrypted_message_with_uuid)
       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
@@ -124,36 +87,15 @@ module Kafkr
     end
 
     def self.send_message_and_wait(message)
-      # Using method(:send_message) to pass the send_message method as a callable object
-
       Consumer.new.listen_for(message, 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
+        if received_message.key? "reply" and received_message["reply"].dig("uuid") == sync_uid
+          received_message["reply"].dig("payload")
         end
       end
     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)
@@ -182,24 +124,6 @@ module Kafkr
       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

data/lib/kafkr/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kafkr
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Delaney Kuldvee Burke
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-25 00:00:00.000000000 Z
+date: 2024-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gibberish
@@ -35,6 +35,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".DS_Store"
 - ".rspec"
 - ".standard.yml"
 - README.md
@@ -71,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.5
 signing_key:
 specification_version: 4
 summary: A homage to kafkr implmented in ruby