kafkr 0.5.7 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61f0dfd7c65259a4684880f7a1ba6f7749f95de46e4eee8faf4b6d629604f3d2
-  data.tar.gz: e8ca8789b46ea257d93381e54b4ae8ad343e38fbf16bae276527f1abc3128867
+  metadata.gz: 3a404654568d9f0c4a16e16f2341757b231cefd27e02186a4de5e34e945afe07
+  data.tar.gz: 3acf9756a6d8ff3f372d595171cb967736430768c6181b7aca9e79f44061bc8f
 SHA512:
-  metadata.gz: 882d352ee426b9ea072d70cefa25502fcb56a616672ddae678f7f7390a6958f40657bd53cd05f4921717b46ac3129bb95bd996c5a5998c491d1673c5c0cac6a3
-  data.tar.gz: 711faef688da9ec89affd06f51e8b7a57af39e37a9e214425e3a15e1bf755852e754e1188445f831eaa4e785c4cf583ae3863c73599325b64c0f4672efc0e225
+  metadata.gz: b7ca82215482129450e112709ed46533be1638d525b433d92d571b188f93d01c787be4a4eb31cad4509d7c96df23850795bf77171972178491c2ed850868a2e0
+  data.tar.gz: 7bb54ca0f2ac1fdd3a4db32c12f8e90bc70dfd272007b9b17204a177d488788f5c3c4430a2f12920e07c614f92deac0cd8d3b4a007ee4fc12253dea4b0efe447

data/exe/kafkr

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+require_relative "../lib/kafkr.rb"
+
 PORT = ENV["KAFKR_PORT"] || 4000
 
 begin
@@ -10,7 +12,7 @@ end
 
 begin
   server = Kafkr::Log.new(PORT.to_i)
-  puts "Log started on port #{PORT}!"
+  puts "Kafkr Log version #{Kafkr::VERSION} started on port #{PORT}!"
   server.start
 rescue => e
   puts "An error occurred: #{e.message}"

data/exe/kafkr-consumer

@@ -33,7 +33,7 @@ def list_registered_handlers
   end
 end
 
-def start_consumer(port,host)
+def start_consumer(port, host)
   puts "Starting consumer on port #{port}!"
   $handlers_changed = false
 
@@ -95,13 +95,13 @@ end
 
 file_checksums = {}
 monitoring_thread = Thread.new { monitor_handlers(file_checksums) }
-start_consumer(port,host)  # Pass the port here
+start_consumer(port, host)  # Pass the port here
 
 begin
   loop do
     if $restart_required
       stop_consumer
-      start_consumer(port,host)
+      start_consumer(port, host)
       $restart_required = false
     end
     sleep 1

data/exe/kafkr-producer

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-require 'readline'
+require "readline"
 
 # Parsing command line arguments for host and port
 host = ARGV[0] || "localhost"

data/lib/kafkr/consumer.rb

@@ -18,6 +18,7 @@ module Kafkr
       def configuration
         FileUtils.mkdir_p "./.kafkr"
         @configuration ||= OpenStruct.new
+        @configuration.suggest_handlers = false
         @configuration
       end
 
@@ -38,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]
@@ -47,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
 
@@ -64,21 +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,47 +107,38 @@ 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 valid_class_name? name.capitalize
-        puts "No handler for this message, you could use this one."
-        puts ""
+      if Kafkr::Consumer.configuration.suggest_handlers
+        if valid_class_name?(name.capitalize)
+          puts "No handler for this message, you could use this one.\n\n"
 
-        handler_class_string = <<~HANDLER_CLASS
+          handler_class_string = <<~HANDLER_CLASS
+            class #{name.capitalize}Handler < Kafkr::Consumer::Handler
+              def handle?(message)
+                can_handle? message, '#{name}'
+              end
 
-          class #{name.capitalize}Handler < Kafkr::Consumer::Handler
-            def handle?(message)
-              can_handle? message, '#{name}'
+              def handle(message)
+                puts message
+              end
             end
-      
-            def handle(message)
-              puts message
-            end
-          end
-
-          save the file to ./handlers/#{name}_handler.rb
 
-        HANDLER_CLASS
+            # Save the file to ./handlers/#{name}_handler.rb
+          HANDLER_CLASS
 
-        puts handler_class_string
+          puts handler_class_string
+        end
       end
     end
 
@@ -163,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
+            received_message = Kafkr::Encryptor.new.decrypt(received_message.chomp)
             if valid_json?(received_message)
-               payload =yield JSON.parse(received_message),sync_uid if block_given?
-               return payload if payload
+              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
+      rescue Timeout::Error, LostConnection, Errno::ECONNREFUSED
         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..."
+        puts "Attempt #{attempt}: Retrying in #{wait_time} seconds..."
         sleep(wait_time)
+        retry
       rescue Interrupt
         puts "Received interrupt signal. Shutting down consumer gracefully..."
         socket&.close
@@ -205,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
 
@@ -271,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,27 +68,14 @@ module Kafkr
     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)
+      # 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
   end

data/lib/kafkr/producer.rb

@@ -10,17 +10,14 @@ 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
     end
 
@@ -31,79 +28,54 @@ 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 message.is_a? String
-        message = structured_data_to_hash(input: message, sync_uid: uuid)
-        message_with_uuid = "#{uuid}: #{message}"
-      end
+      if Kafkr::Producer.configuration.is_json
+        json_message = JSON.parse(message)
+        json_message["uuid"] = uuid
+        message_with_uuid = JSON.dump(json_message)
+      else
+        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)}"
+        if message.is_a?(Hash)
+          message_with_uuid = "#{uuid}: #{JSON.generate(message)}"
+        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
@@ -115,39 +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
-      
-      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
+      Consumer.new.listen_for(message, method(:send_message)) do |received_message, sync_uid|
+        if received_message.key? "reply" and received_message["reply"].dig("uuid") == sync_uid
+          received_message["reply"].dig("payload")
         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)
@@ -176,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.5.7"
+  VERSION = "0.10.0"
 end

data/lib/kafkr.rb

@@ -11,6 +11,7 @@ require_relative "kafkr/message_broker"
 require_relative "kafkr/log"
 require_relative "kafkr/consumer"
 require_relative "kafkr/producer"
+require_relative "kafkr/version"
 
 module Kafkr
   class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kafkr
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.10.0
 platform: ruby
 authors:
 - Delaney Kuldvee Burke
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-19 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