jruby_parallel_processing 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbbe1ea28c91fad4e363c47c0022570c78d0b23704b5d3f64dd9650685a90200
+  data.tar.gz: 996cdc75cb9fa9edc861799938799449d432749674d998c19dc454b352bc7451
+SHA512:
+  metadata.gz: 8ea06ce65c37b74548970bf8f33b2fc959116199ee2358578cd3824a3fb9ced3d1646e313722021469f584cd8cdb9d9a3ff3c42e4b62f699be9a8ab9fa01c847
+  data.tar.gz: de99438a31bab4456c20b8ee3a6b9b88b59f1fc21c1a54163d703298922fcc905c37292e0d0856083cf5bc14a9767633d7bc1fc473f994927b4eb1ed3d794287

data/.rspec

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

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-08-30
+
+- Initial release

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in jruby_parallel_processing.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "drb", "~> 2.2"
+
+gem "nokogiri", "~> 1.16"

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    jruby_parallel_processing (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.1)
+    drb (2.2.1)
+    nokogiri (1.16.7-java)
+      racc (~> 1.4)
+    racc (1.8.1-java)
+    rake (13.2.1)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+
+PLATFORMS
+  universal-java-17
+
+DEPENDENCIES
+  drb (~> 2.2)
+  jruby_parallel_processing!
+  nokogiri (~> 1.16)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.3.26

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Netsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# JRubyParallelProcessing
+## Table of Contents
+- [Overview](#overview)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [DataProcessor](#dataprocessor)
+    - [Basic Example](#basic-example)
+    - [Features](#features)
+    - [Configuration](#configuration)
+  - [TaskQueue](#taskqueue)
+    - [Basic Example](#basic-example-1)
+    - [Features](#features-1)
+    - [Configuration](#configuration-1)
+  - [ApiRequestProcessor](#apirequestprocessor)
+    - [Basic Example](#basic-example-2)
+    - [Features](#features-2)
+    - [Configuration](#configuration-2)
+  - [DistributedWorker](#distributedworker)
+    - [Basic Example](#basic-example-3)
+    - [Features](#features-3)
+    - [Configuration Options](#configuration-options)
+- [License](#license)
+## Overview
+
+`JRubyParallelProcessing` is a gem designed for parallel processing tasks in JRuby. It offers efficient data processing and API request handling using multiple threads, along with a task queue system for managing and executing tasks with priority and retries.
+
+## Installation
+Add this gem to your Gemfile:
+``` ruby
+gem 'jruby_parallel_processing'
+```
+## Usage
+
+### DataProcessor
+`DataProcessor` is a class designed for parallel data processing. It allows you to split data into chunks and process them across multiple threads, which significantly speeds up task execution. Additionally, it supports middleware hooks for customizing the behavior before and after processing.
+
+#### Basic Example
+``` ruby
+require 'jruby_parallel_processing'
+data = (1..100).to_a
+processor = JRubyParallelProcessing::DataProcessor.new(data_array: data, in_threads: 4)
+processor.process do |item|
+# Your processing logic here
+puts item
+end
+```
+#### Features
+ - Efficient Parallel Processing: Process data using multiple threads. 
+ - Chunk Management: Automatically splits data into manageable chunks.
+ - Stream Support: Handles data processing from streams (e.g., IO, StringIO).
+ - Middleware: Supports before and after processing middleware for custom logic injection.
+
+#### Configuration
+ - data_array: Array of data to be processed.
+ - stream: Stream object (e.g., IO, StringIO) for processing data line-by-line.
+ - in_threads: Number of threads for parallel processing (default is 4).
+ - chunk_size: Size of chunks for processing.
+ - logger: Logger object for custom logging.
+ - queue_size: Size of the queue for stream processing (default is 100).
+ - timeout: Timeout for stream processing (default is 10 seconds).
+
+### Example Usage
+#### Middleware Example
+``` ruby
+processor = JRubyParallelProcessing::DataProcessor.new(data_array: data, in_threads: 4)
+# Add before processing middleware
+processor.add_middleware(:before_process) do
+  puts "Starting processing..."
+end
+# Add after processing middleware
+processor.add_middleware(:after_process) do
+  puts "Finished processing."
+end
+processor.process do |item|
+  puts item
+end
+```
+#### Data Processing from Stream:
+```ruby
+require 'stringio'
+require 'jruby_parallel_processing'
+stream = StringIO.new("line 1\nline 2\nline 3\n")
+processor = JRubyParallelProcessing::DataProcessor.new(stream: stream, in_threads: 2)
+processor.process do |line|
+puts line
+end
+```
+
+## TaskQueue
+`TaskQueue` is a class for managing and executing tasks with priority, retries, and custom configurations. It allows for efficient task scheduling and error handling.
+
+#### Basic Example
+```ruby
+require 'jruby_parallel_processing'
+task_queue = JRubyParallelProcessing::TaskQueue.new(max_retries: 3, retry_delay: 0.1, max_queue_size: 10)
+task_queue.add_task(1) do
+# Your task logic here
+puts "Task executed"
+end
+task_queue.process_tasks
+```
+#### Features
+
+ - Adds tasks to the queue with priority.
+ - Retries failed tasks with configurable retry count and delay.
+ - Handles task execution using a fixed thread pool.
+
+#### Configuration
+ - max_retries: Maximum number of retries for failed tasks (default is
+   3).
+ - retry_delay: Delay between retries in seconds (default is 0.1).
+ - max_queue_size: Maximum number of tasks in the queue (default is 10).
+ - logger: Logger object for custom logging.
+
+## ApiRequestProcessor
+`ApiRequestProcessor` handles parallel API requests with built-in error handling and retries.
+
+#### Basic Example
+```ruby
+urls = ["https://api.example.com/data", "https://api.example.com/other"]
+processor = JRubyParallelProcessing::ApiRequestProcessor.new(urls, in_threads: 4)
+results = processor.process(http_method: :get) do |response|
+puts "Received response: #{response.body}"
+end
+```
+  
+
+#### Features
+
+ - Parallel API requests with configurable HTTP methods, timeouts, and
+   retries.
+ - Supports custom headers and parameters for requests.
+ - Automatically parses responses in various formats.
+
+#### Configuration
+
+ - urls: Array of URLs for API requests.
+ - in_threads: Number of threads for parallel API requests (default is
+   4).
+ - timeout: Timeout for API requests (default is 5 seconds).
+ - retries: Number of retries for failed requests (default is 3).
+ - logger: Logger object for custom logging.
+ - http_method: HTTP method to use (default is GET).
+ - headers: Custom headers for requests.
+ - params: Parameters for POST/PUT requests.
+
+
+## DistributedWorker
+`DistributedWorker` is a class for managing distributed tasks across multiple worker nodes. It enables task distribution, prioritization, and ensures that workers remain active through a heartbeat mechanism.
+
+#### Basic Example
+```ruby
+require 'jruby_parallel_processing'
+# Initialize a DistributedWorker instance
+worker = JRubyParallelProcessing::DistributedWorker.new("localhost", 8787)
+# Queue a task with a given priority
+result = worker.execute_task(-> { puts "Task executed" }, priority: 5)
+puts result[:status]  # :queued
+# To connect to an existing worker
+worker_url = "druby://localhost:8787"
+remote_worker = JRubyParallelProcessing::DistributedWorker.connect_to_worker(worker_url)
+# Send a heartbeat to the worker
+remote_worker.send_heartbeat
+```
+#### Features
+ - Distributed Task Execution: Distribute tasks to different worker nodes.
+ - Task Prioritization: Tasks are queued with priority, ensuring high-priority tasks are processed first.
+ - Heartbeat Mechanism: Ensures worker nodes remain active and can report their status.
+ - Fault-Tolerant Task Queue: Handles errors during task queueing and processing.
+
+#### Configuration Options
+ - host: Host address for the DistributedWorker service (default is localhost).
+ - port: Port for the DistributedWorker service (default is 8787).
+ - priority: Priority of the task being queued (default is 0).
+
+## License
+This gem is licensed under the MIT License.

data/Rakefile

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

data/lib/jruby_parallel_processing/api_request_processor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module JRubyParallelProcessing
+  class ApiRequestProcessor
+    def initialize(urls, in_threads: 4, timeout: 5, retries: 3, logger: nil)
+      @urls = urls
+      @in_threads = in_threads
+      @timeout = timeout
+      @retries = retries
+      @logger = logger || Logger.new(STDOUT)
+    end
+
+    def process(http_method: :get, headers: {}, params: {}, &block)
+      results = []
+      data_processor = DataProcessor.new(data_array: @urls, in_threads: @in_threads)
+
+      data_processor.process do |url|
+        response = nil
+        attempts = 0
+
+        begin
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+          http.read_timeout = @timeout
+
+          request = build_request(http_method, uri, headers, params)
+
+          response = http.request(request)
+          results << {url: url, response: parse_response(response), status: response.code}
+          @logger.info("Request to #{url} succeeded with status #{response.code}")
+        rescue => e
+          attempts += 1
+          @logger.error("Request to #{url} failed: #{e.message}, attempt #{attempts}")
+
+          if attempts <= @retries
+            retry
+          else
+            results << {url: url, error: e.message}
+            @logger.error("Request to #{url} failed after #{@retries} retries.")
+          end
+        end
+
+        block.call(response) if block && response
+      end
+
+      results
+    end
+
+    private
+
+    def build_request(http_method, uri, headers, params)
+      case http_method
+      when :get
+        uri.query = URI.encode_www_form(params) unless params.empty?
+        Net::HTTP::Get.new(uri.request_uri, headers)
+      when :post
+        request = Net::HTTP::Post.new(uri.request_uri, headers)
+        request.set_form_data(params)
+        request
+      when :put
+        request = Net::HTTP::Put.new(uri.request_uri, headers)
+        request.set_form_data(params)
+        request
+      when :delete
+        Net::HTTP::Delete.new(uri.request_uri, headers)
+      else
+        raise ArgumentError, "Unsupported HTTP method: #{http_method}"
+      end
+    end
+
+    def parse_response(response)
+      content_type = response["content-type"]
+      case content_type
+      when /json/
+        JSON.parse(response.body)
+      when /xml/
+        Nokogiri::XML(response.body)
+      when /html/
+        Nokogiri::HTML(response.body)
+      else
+        response.body
+      end
+    rescue
+      response.body
+    end
+  end
+end

data/lib/jruby_parallel_processing/application_callable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JRubyParallelProcessing
+  class ApplicationCallable
+    include Callable
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def call
+      @block.call
+    end
+  end
+end

data/lib/jruby_parallel_processing/chunk_processor.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module JRubyParallelProcessing
+  module ChunkProcessor
+    def process_chunk(chunk, &block)
+      chunk.each do |data|
+        block.call(data)
+      rescue => e
+        @logger.error("Error processing data: #{e.message}")
+      end
+    end
+  end
+end

data/lib/jruby_parallel_processing/data_processor.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module JRubyParallelProcessing
+  class DataProcessor
+    include ChunkProcessor
+
+    def initialize(data_array: nil, stream: nil, in_threads: 4, chunk_size: nil, logger: nil, queue_size: 100, timeout: 10)
+      @data_array = data_array
+      @stream = stream
+      @in_threads = in_threads
+      @chunk_size = chunk_size || (@data_array.size.to_f / in_threads).ceil if @data_array
+      @logger = logger || Logger.new(STDOUT)
+      @queue_size = queue_size
+      @timeout = timeout
+      @middlewares = { before_process: [], after_process: [] }
+    end
+
+    def process(&block)
+      raise ArgumentError, "Data array or stream must be provided" unless @data_array || @stream
+
+      execute_middleware(:before_process)
+
+      @logger.info("Processing started with #{@in_threads} threads")
+      executor = Executors.new_fixed_thread_pool(@in_threads)
+      futures = []
+
+      if @data_array
+        chunks = @data_array.each_slice(@chunk_size).to_a
+        futures = submit_chunks(executor, chunks, &block)
+      elsif @stream
+        futures = submit_stream(executor, @stream, &block)
+      end
+
+      await_completion(futures, executor)
+
+      execute_middleware(:after_process)
+    end
+
+    def add_middleware(position, &middleware_block)
+      raise ArgumentError, "Invalid middleware position" unless @middlewares.key?(position)
+
+      @middlewares[position] << middleware_block
+    end
+
+    private
+
+    def submit_chunks(executor, chunks, &block)
+      chunks.map do |chunk|
+        executor.submit do
+          process_chunk(chunk, &block)
+        end
+      end
+    end
+
+    def submit_stream(executor, stream, &block)
+      queue = LinkedBlockingQueue.new(@queue_size)
+      futures = []
+
+      stream_reader_thread = Thread.new do
+        until stream.eof?
+          line = stream.gets
+          queue.put(line) if line
+        end
+      rescue => e
+        @logger.error("Error reading from stream: #{e.message}")
+      end
+
+      callable = StreamProcessorCallable.new(queue, @logger, block)
+      futures << executor.submit(callable)
+
+      stream_reader_thread.join(@timeout)
+      raise "Stream reading timeout" if stream_reader_thread.alive?
+
+      futures
+    end
+
+    def await_completion(futures, executor)
+      futures.each do |future|
+        future.get
+      rescue => e
+        @logger.error("Task failed: #{e.message}")
+      end
+      executor.shutdown
+      @logger.info("Processing completed")
+    end
+
+    def execute_middleware(position)
+      return unless @middlewares[position]
+
+      @middlewares[position].each(&:call)
+    end
+  end
+end

data/lib/jruby_parallel_processing/distributed_worker.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+ 
+module JRubyParallelProcessing
+  class DistributedWorker
+    HEARTBEAT_INTERVAL = 10
+
+    def initialize(host = "localhost", port = 8787)
+      @server = DRb.start_service("druby://#{host}:#{port}", self)
+      @last_heartbeat = Time.now
+      @task_queue = java.util.concurrent.PriorityBlockingQueue.new
+      @executor = java.util.concurrent.Executors.newFixedThreadPool(4)  
+      @heartbeat_thread = start_heartbeat
+      @task_processing_thread = start_task_processing
+    end
+
+    def execute_task(task, priority: 0)
+      begin
+        @task_queue.put(PrioritizedTask.new(task, priority))
+        { status: :queued }
+      rescue => e
+        { status: :failed, error: e.message }
+      end
+    end
+
+    def self.connect_to_worker(worker_url)
+      DRbObject.new_with_uri(worker_url)
+    end
+
+    def send_heartbeat
+      @last_heartbeat = Time.now
+    end
+
+    def last_heartbeat
+      @last_heartbeat
+    end
+
+    def shutdown
+      @executor.shutdown
+      unless @executor.await_termination(10, java.util.concurrent.TimeUnit::SECONDS)
+        @logger.warn("Executor did not terminate in the expected time. Initiating forced shutdown.")
+        @executor.shutdown_now
+        @executor.await_termination(10, java.util.concurrent.TimeUnit::SECONDS)
+      end
+
+      @heartbeat_thread.interrupt if @heartbeat_thread
+      @task_processing_thread.interrupt if @task_processing_thread
+      @server.stop_service
+     end
+
+    private
+
+    def start_heartbeat
+      java.lang.Thread.new do
+        loop do
+          java.lang.Thread.sleep(HEARTBEAT_INTERVAL * 1000)
+          send_heartbeat
+        end
+      end.tap(&:start)
+    end
+
+    def start_task_processing
+      java.lang.Thread.new do
+        loop do
+          task = @task_queue.take
+          @executor.submit(TaskCallable.new(task))
+        end
+      end.tap(&:start)
+    end
+
+    class PrioritizedTask
+      include Comparable
+      attr_reader :task, :priority
+
+      def initialize(task, priority)
+        @task = task
+        @priority = priority
+      end
+
+      def <=>(other)
+        other.priority <=> @priority 
+      end
+    end
+  end
+end

data/lib/jruby_parallel_processing/stream_processor_callable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JRubyParallelProcessing
+  class StreamProcessorCallable < ApplicationCallable
+    include ChunkProcessor
+
+    def initialize(queue, logger, process_chunk_block)
+      super(&method(:process))
+      @queue = queue
+      @logger = logger
+      @process_chunk_block = process_chunk_block
+    end
+
+    private
+
+    def process
+      loop do
+        line = @queue.poll
+        break if line.nil?
+
+        @logger.info("Processing line: #{line.inspect}")
+        process_chunk([line], &@process_chunk_block)
+      rescue => e
+        @logger.error("Error during processing: #{e.message}")
+      end
+    end
+  end
+end

data/lib/jruby_parallel_processing/task_callable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JRubyParallelProcessing
+  class TaskCallable < ApplicationCallable
+    def initialize(prioritized_task)
+      @task = prioritized_task.task
+      super(&method(:call_task))
+    end
+
+    private
+
+    def call_task
+      begin
+        @task.call
+      rescue => e
+        puts "Task failed with error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/jruby_parallel_processing/task_queue.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module JRubyParallelProcessing
+  class TaskQueue
+    def initialize(max_retries: 3, retry_delay: 0.1, max_queue_size: 10, logger: nil)
+      @max_retries = max_retries
+      @retry_delay = retry_delay
+      @queue = LinkedBlockingQueue.new(max_queue_size)
+      @executor = Executors.new_fixed_thread_pool(10)
+      @logger = logger || Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+    end
+
+    def add_task(priority, &task)
+      raise 'Queue is full' if @queue.remaining_capacity == 0
+      @queue.put([priority, task])
+    end
+
+    def process_tasks
+      tasks = []
+      while (task = @queue.poll)
+        tasks << task
+      end
+
+      sorted_tasks = tasks.sort_by(&:first)
+      sorted_tasks.each do |(_, task)|
+        retry_count = 0
+        begin
+          future = @executor.submit(ApplicationCallable.new(&task))
+          future.get  
+        rescue => e
+          retry_count += 1
+          if retry_count <= @max_retries
+            @logger.info("Task failed with error: #{e.message}. Retrying (attempt #{retry_count})")
+            sleep @retry_delay
+            retry
+          else
+            @logger.error("Task failed with error: #{e.message}. Max retries reached.")
+            future.cancel(true) if future.respond_to?(:cancel)
+          end
+        end
+      end
+    end
+
+    def shutdown
+      @logger.info("Shutting down executor.")
+      @executor.shutdown
+      unless @executor.await_termination(10, java.util.concurrent.TimeUnit::SECONDS)
+        @logger.warn("Executor did not terminate in the expected time. Initiating forced shutdown.")
+        @executor.shutdown_now
+        @executor.await_termination(10, java.util.concurrent.TimeUnit::SECONDS)
+      end
+      @logger.info("Executor shutdown completed.")
+    end
+  end
+end

data/lib/jruby_parallel_processing/version.rb

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

data/lib/jruby_parallel_processing.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "java"
+require "logger"
+java_import "java.util.concurrent.Executors"
+java_import "java.util.concurrent.Callable"
+java_import "java.util.concurrent.Future"
+java_import "java.util.concurrent.LinkedBlockingQueue"
+java_import "java.util.concurrent.locks.ReentrantLock"
+java_import "java.util.concurrent.TimeUnit"
+java_import 'java.util.concurrent.CountDownLatch'
+require_relative "jruby_parallel_processing/version"
+require "drb/drb"
+require "net/http"
+require "nokogiri"
+require "json"
+require_relative "jruby_parallel_processing/chunk_processor"
+require_relative "jruby_parallel_processing/application_callable"
+require_relative "jruby_parallel_processing/stream_processor_callable"
+require_relative "jruby_parallel_processing/task_callable"
+require_relative "jruby_parallel_processing/data_processor"
+require_relative "jruby_parallel_processing/api_request_processor"
+require_relative "jruby_parallel_processing/task_queue"
+require_relative "jruby_parallel_processing/distributed_worker"
+
+module JRubyParallelProcessing
+  class Error < StandardError; end
+end

data/sig/jruby_parallel_processing.rbs

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

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: jruby_parallel_processing
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Netsky
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-09-06 00:00:00.000000000 Z
+dependencies: []
+description: JRubyParallelProcessing is a gem for parallel processing tasks in JRuby.
+  It provides classes for efficient data processing, task management with priority
+  and retries, and parallel API request handling. It includes features such as middleware
+  support, stream processing, and distributed task execution.
+email:
+- netsky_prod@proton.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/jruby_parallel_processing.rb
+- lib/jruby_parallel_processing/api_request_processor.rb
+- lib/jruby_parallel_processing/application_callable.rb
+- lib/jruby_parallel_processing/chunk_processor.rb
+- lib/jruby_parallel_processing/data_processor.rb
+- lib/jruby_parallel_processing/distributed_worker.rb
+- lib/jruby_parallel_processing/stream_processor_callable.rb
+- lib/jruby_parallel_processing/task_callable.rb
+- lib/jruby_parallel_processing/task_queue.rb
+- lib/jruby_parallel_processing/version.rb
+- sig/jruby_parallel_processing.rbs
+homepage: https://gitlab.com/netsky_prod/jruby-parallel-processing
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://gitlab.com/netsky_prod/jruby-parallel-processing
+  source_code_uri: https://gitlab.com/netsky_prod/jruby-parallel-processing
+  changelog_uri: https://gitlab.com/netsky_prod/jruby-parallel-processing/-/releases
+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.3.26
+signing_key:
+specification_version: 4
+summary: Efficient parallel processing in JRuby with support for data processing,
+  task management, and API requests.
+test_files: []