flexiq 2.1.0

data/lib/flexiq/wire/duration.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  module Wire
+    # proto3 JSON `google.protobuf.Duration`: seconds with an `s` suffix, as in `"30s"` or `"1.500s"`.
+    module Duration
+      NANOS_PER_SECOND = 1_000_000_000
+      PATTERN = /\A(-)?(\d+)(?:\.(\d{1,9}))?s\z/
+
+      module_function
+
+      # Seconds (Integer, Float or Rational) to the wire string; nanosecond precision.
+      def dump(seconds)
+        raise ArgumentError, "a duration must be Numeric, got #{seconds.class}" unless seconds.is_a?(Numeric)
+        raise ArgumentError, "a duration must be finite" if seconds.is_a?(Float) && !seconds.finite?
+        raise ArgumentError, "a duration cannot be negative: #{seconds}" if seconds.negative?
+
+        whole, nanos = (seconds.to_r * NANOS_PER_SECOND).round.divmod(NANOS_PER_SECOND)
+        "#{whole}#{fraction(nanos)}s"
+      end
+
+      # The wire string to seconds as a Rational, so no precision is lost; nil when unreadable.
+      def load(text)
+        match = PATTERN.match(text.to_s) or return nil
+
+        magnitude = Integer(match[2], 10) + Rational(Integer((match[3] || "0").ljust(9, "0"), 10), NANOS_PER_SECOND)
+        match[1] ? -magnitude : magnitude
+      end
+
+      # Same digit groups the server writes: none, millis, micros or nanos.
+      def fraction(nanos)
+        if nanos.zero? then ""
+        elsif (nanos % 1_000_000).zero? then format(".%03d", nanos / 1_000_000)
+        elsif (nanos % 1_000).zero? then format(".%06d", nanos / 1_000)
+        else format(".%09d", nanos)
+        end
+      end
+      private_class_method :fraction
+    end
+  end
+end

data/lib/flexiq/wire/int64.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  module Wire
+    # proto3 JSON writes 64-bit integers as strings, since a JSON number is a double.
+    module Int64
+      module_function
+
+      def dump(value) = Integer(value).to_s
+
+      # Accepts the string form and, leniently, a bare number; nil when unreadable.
+      def load(value)
+        case value
+        when Integer then value
+        when String then Integer(value, 10, exception: false)
+        end
+      end
+    end
+  end
+end

data/lib/flexiq/wire/path.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  module Wire
+    # Builds request paths from caller-supplied names.
+    module Path
+      UNRESERVED = /[^A-Za-z0-9\-._~]/
+
+      module_function
+
+      # Percent-encodes one path segment, so an id or queue name cannot add segments or a verb.
+      def segment(value)
+        text = value.to_s
+        raise ArgumentError, "a path segment cannot be empty" if text.empty?
+
+        text.b.gsub(UNRESERVED) { |char| format("%%%02X", char.ord) }
+      end
+    end
+  end
+end

data/lib/flexiq/wire/sse.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  module Wire
+    # WHATWG `text/event-stream`, the framing of a watch.
+    module SSE
+      # `id`: this event's own id field, or nil. `type`: "message" unless `event` set one.
+      Event = Data.define(:id, :type, :data)
+
+      # Incremental parser. Holds partial lines across chunks; skips comments and `retry`;
+      # an event never ended by a blank line is dropped.
+      class Parser
+        LINE_BREAK = /[\r\n]/
+        CR = 13
+        LF = 10
+        private_constant :LINE_BREAK, :CR, :LF
+
+        # Bound on an unfinished line and on one event's data. A watch item is a few hundred
+        # bytes; a peer that never ends a line or event must not grow memory without bound.
+        MAX_BYTES = 1 << 20
+
+        def initialize(max_bytes: MAX_BYTES)
+          @max_bytes = max_bytes
+          @buffer = "".b
+          @after_cr = false
+          reset_event
+        end
+
+        # Yields each event the chunk completes.
+        def feed(chunk, &)
+          @buffer << chunk.b
+          drop_lf_after_cr
+          while (index = @buffer.index(LINE_BREAK))
+            line = @buffer.byteslice(0, index)
+            @after_cr = @buffer.getbyte(index) == CR
+            @buffer = @buffer.byteslice((index + 1)..)
+            drop_lf_after_cr
+            process(line, &)
+          end
+          limit!(@buffer, "line")
+        end
+
+        private
+
+        # CR ends a line at once; skip the LF of a CRLF split across chunks.
+        def drop_lf_after_cr
+          return if !@after_cr || @buffer.empty?
+
+          @buffer = @buffer.byteslice(1..) if @buffer.getbyte(0) == LF
+          @after_cr = false
+        end
+
+        def process(line, &)
+          return dispatch(&) if line.empty?
+          return if line.start_with?(":")
+
+          field, value = line.split(":", 2)
+          value = value.nil? ? "".b : value.delete_prefix(" ")
+          case field
+          when "data" then limit!(@data << value << "\n", "event")
+          when "event" then @type = value
+          when "id" then @id = value unless value.include?("\0")
+          end
+        end
+
+        def limit!(bytes, what)
+          return if bytes.bytesize <= @max_bytes
+
+          raise TransportError, "an event-stream #{what} passed #{@max_bytes} bytes unfinished"
+        end
+
+        def dispatch
+          unless @data.empty?
+            type = @type.nil? || @type.empty? ? "message" : text(@type)
+            yield Event.new(id: @id && text(@id), type: type, data: text(@data.chomp))
+          end
+          reset_event
+        end
+
+        def reset_event
+          @id = nil
+          @type = nil
+          @data = "".b
+        end
+
+        # UTF-8; malformed bytes become U+FFFD.
+        def text(bytes) = bytes.dup.force_encoding(Encoding::UTF_8).scrub
+      end
+    end
+  end
+end

data/lib/flexiq/wire/timestamp.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "time"
+
+module FlexiQ
+  module Wire
+    # proto3 JSON `google.protobuf.Timestamp`: an RFC 3339 instant in UTC.
+    module Timestamp
+      module_function
+
+      def dump(time)
+        raise ArgumentError, "a timestamp must be a Time, got #{time.class}" unless time.is_a?(Time)
+
+        time.getutc.iso8601(9)
+      end
+
+      # nil for an absent or unreadable value: a bad timestamp should not sink the whole job.
+      def load(text)
+        return nil if text.nil?
+
+        Time.iso8601(text)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/flexiq/workflow_constructs.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # The dynamic workflow constructs. `Client#submit_workflow` refuses any node setting one, with
+  # reason WORKFLOW_CONSTRUCT_UNSUPPORTED: only a live SDK process can advance them. They are
+  # here because the wire carries them and the refusal names the field it refused.
+  #
+  # Durations are seconds; an unset field is omitted, and an empty construct still counts as set.
+
+  # Pause the node for an external decision. `on_timeout` is `:approve` or `:reject`.
+  GateConfig = Data.define(:timeout, :on_timeout, :message) do
+    def initialize(timeout: nil, on_timeout: nil, message: nil) = super
+
+    def to_wire
+      {
+        "timeout" => timeout && Wire::Duration.dump(timeout),
+        "onTimeout" => on_timeout && on_timeout_wire,
+        "message" => message
+      }.compact
+    end
+
+    private
+
+    def on_timeout_wire
+      case on_timeout
+      when :approve then "ON_TIMEOUT_APPROVE"
+      when :reject then "ON_TIMEOUT_REJECT"
+      else raise ArgumentError, "a gate's on_timeout must be :approve or :reject, got #{on_timeout.inspect}"
+      end
+    end
+  end
+
+  # Memoize the node's result; nil `ttl` caches indefinitely.
+  CacheConfig = Data.define(:ttl) do
+    def initialize(ttl: nil) = super
+
+    def to_wire = { "ttl" => ttl && Wire::Duration.dump(ttl) }.compact
+  end
+
+  # Expand the node into one job per item of `items_from`'s result.
+  FanOutConfig = Data.define(:items_from) do
+    def initialize(items_from: nil) = super
+
+    def to_wire = { "itemsFrom" => items_from }.compact
+  end
+
+  # Collect the fan-out node `from` back into one node.
+  FanInConfig = Data.define(:from) do
+    def to_wire = { "from" => from }
+  end
+
+  # Run a child workflow as this node.
+  SubWorkflowSpec = Data.define(:name, :version, :graph, :deferred_node_names) do
+    def initialize(name:, graph:, version: nil, deferred_node_names: [])
+      graph = WorkflowGraph.new(**graph) if graph.is_a?(Hash)
+      super
+    end
+
+    def to_wire
+      {
+        "name" => name, "version" => version, "graph" => graph.to_wire,
+        "deferredNodeNames" => deferred_node_names.empty? ? nil : deferred_node_names
+      }.compact
+    end
+  end
+end

data/lib/flexiq/workflow_edge.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # One edge of a workflow graph: `from` must finish before `to` becomes eligible.
+  WorkflowEdge = Data.define(:from, :to) do
+    # An edge from a WorkflowEdge, a `[from, to]` pair or a Hash of its fields.
+    def self.coerce(edge)
+      case edge
+      when WorkflowEdge then edge
+      when Hash then new(**edge)
+      when Array
+        raise ArgumentError, "an edge pair must have two names, got #{edge.length}" unless edge.length == 2
+
+        new(from: edge[0], to: edge[1])
+      else raise ArgumentError, "an edge must be a WorkflowEdge, a [from, to] pair or a Hash, got #{edge.class}"
+      end
+    end
+
+    def to_wire = { "from" => from, "to" => to }
+  end
+end

data/lib/flexiq/workflow_graph.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # A workflow's shape: its nodes and the edges between them.
+  #
+  # `nodes` are WorkflowNode (or Hashes of its fields); `edges` are WorkflowEdge, `[from, to]`
+  # pairs or Hashes. A node with no inbound edge is eligible as soon as the run starts.
+  WorkflowGraph = Data.define(:nodes, :edges) do
+    def initialize(nodes:, edges: [])
+      raise ArgumentError, "nodes must be an Array, got #{nodes.class}" unless nodes.is_a?(Array)
+      raise ArgumentError, "edges must be an Array, got #{edges.class}" unless edges.is_a?(Array)
+
+      nodes = nodes.map { |node| node.is_a?(Hash) ? WorkflowNode.new(**node) : node }
+      super(nodes: nodes.freeze, edges: edges.map { |edge| WorkflowEdge.coerce(edge) }.freeze)
+    end
+
+    # Refuses, before any call, a graph the server would refuse in terms of its own compilation:
+    # an edge to an undeclared node fails there as "missing from step_metadata".
+    # A nested sub-workflow graph is not checked; the server refuses the node before reading it.
+    def validate!
+      raise ArgumentError, "a workflow graph needs at least one node" if nodes.empty?
+
+      declared = {}
+      nodes.each do |node|
+        raise ArgumentError, "a graph node must be a WorkflowNode, got #{node.class}" unless node.is_a?(WorkflowNode)
+        raise ArgumentError, "node #{node.name.inspect} is declared twice" if declared.key?(node.name)
+
+        declared[node.name] = true
+      end
+      edges.each do |edge|
+        [edge.from, edge.to].each do |end_name|
+          next if declared.key?(end_name)
+
+          raise ArgumentError,
+                "edge #{edge.from.inspect} -> #{edge.to.inspect} names undeclared node #{end_name.inspect}"
+        end
+      end
+      self
+    end
+
+    # The proto3 JSON `WorkflowGraph`: the bare shape, then each node's configuration by name.
+    def to_wire
+      {
+        "nodes" => nodes.map { |node| { "name" => node.name } },
+        "edges" => edges.map(&:to_wire),
+        "nodeConfigs" => nodes.map(&:to_wire)
+      }
+    end
+  end
+end

data/lib/flexiq/workflow_node.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # One step of a workflow: its name in the graph, the task it runs, the call and its settings.
+  #
+  # The arguments travel as the `raw` CBOR envelope, the same bytes `Client#enqueue` sends.
+  # `timeout` is seconds; `condition` is a FlexiQ::EdgeCondition symbol; `compensate` names the
+  # task a saga rollback runs. `gate`, `cache`, `fan_out`, `fan_in` and `sub_workflow` take their
+  # FlexiQ construct (or a Hash of its fields) and are refused by the server; see GateConfig.
+  WorkflowNode = Data.define(
+    :name, :task_name, :args, :kwargs, :queue, :max_retries, :timeout, :priority, :condition,
+    :compensate, :gate, :cache, :fan_out, :fan_in, :sub_workflow
+  ) do
+    def initialize(name:, task_name:, args: [], kwargs: {}, queue: nil, max_retries: nil, timeout: nil,
+                   priority: nil, condition: nil, compensate: nil, gate: nil, cache: nil, fan_out: nil,
+                   fan_in: nil, sub_workflow: nil)
+      raise ArgumentError, "a node name must be a non-empty String" unless name.is_a?(String) && !name.empty?
+      unless task_name.is_a?(String) && !task_name.empty?
+        raise ArgumentError, "node #{name.inspect} needs a non-empty task_name"
+      end
+
+      super(
+        name: name, task_name: task_name, args: args, kwargs: kwargs, queue: queue, max_retries: max_retries,
+        timeout: timeout, priority: priority, condition: condition, compensate: compensate,
+        gate: coerce(gate, GateConfig), cache: coerce(cache, CacheConfig), fan_out: coerce(fan_out, FanOutConfig),
+        fan_in: coerce(fan_in, FanInConfig), sub_workflow: coerce(sub_workflow, SubWorkflowSpec)
+      )
+    end
+
+    # The proto3 JSON `WorkflowNodeConfig` object, unset fields omitted.
+    def to_wire
+      {
+        "name" => name,
+        "taskName" => task_name,
+        "queue" => queue,
+        "raw" => Wire::Bytes.dump(Payload.encode_call(args, kwargs)),
+        "maxRetries" => max_retries,
+        "timeout" => timeout && Wire::Duration.dump(timeout),
+        "priority" => priority,
+        "condition" => EdgeCondition.dump(condition),
+        "gate" => gate&.to_wire,
+        "cache" => cache&.to_wire,
+        "fanOut" => fan_out&.to_wire,
+        "fanIn" => fan_in&.to_wire,
+        "subWorkflow" => sub_workflow&.to_wire,
+        "compensate" => compensate
+      }.compact
+    end
+
+    private
+
+    def coerce(value, type) = value.is_a?(Hash) ? type.new(**value) : value
+  end
+end

data/lib/flexiq/workflow_node_state.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # One node's state within a run. `status` is a FlexiQ::WorkflowNodeStatus symbol, or the raw
+  # wire value. `job_id` is nil until the node's job exists; read the job with `Client#get_job`.
+  WorkflowNodeState = Data.define(:name, :status, :job_id, :started_at, :completed_at, :error) do
+    def self.from_json(json)
+      new(
+        name: json["name"], status: WorkflowNodeStatus.load(json["status"]), job_id: json["jobId"],
+        started_at: Wire::Timestamp.load(json["startedAt"]),
+        completed_at: Wire::Timestamp.load(json["completedAt"]), error: json["error"]
+      )
+    end
+
+    def terminal? = WorkflowNodeStatus.terminal?(status)
+  end
+end

data/lib/flexiq/workflow_node_status.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # `WorkflowNodeStatus` as symbols. An unknown value stays raw and is never terminal.
+  # A runnable node reads `:pending`: readiness is a predicate over the graph, not a status.
+  module WorkflowNodeStatus
+    BY_WIRE_NAME = {
+      "WORKFLOW_NODE_STATUS_PENDING" => :pending,
+      "WORKFLOW_NODE_STATUS_RUNNING" => :running,
+      "WORKFLOW_NODE_STATUS_COMPLETED" => :completed,
+      "WORKFLOW_NODE_STATUS_FAILED" => :failed,
+      "WORKFLOW_NODE_STATUS_SKIPPED" => :skipped,
+      "WORKFLOW_NODE_STATUS_WAITING_APPROVAL" => :waiting_approval,
+      "WORKFLOW_NODE_STATUS_CACHE_HIT" => :cache_hit,
+      "WORKFLOW_NODE_STATUS_COMPENSATING" => :compensating,
+      "WORKFLOW_NODE_STATUS_COMPENSATED" => :compensated,
+      "WORKFLOW_NODE_STATUS_COMPENSATION_FAILED" => :compensation_failed
+    }.freeze
+
+    KNOWN = BY_WIRE_NAME.values.freeze
+    TERMINAL = %i[completed failed skipped cache_hit compensated compensation_failed].freeze
+
+    module_function
+
+    def load(value) = BY_WIRE_NAME.fetch(value, value)
+
+    def known?(status) = KNOWN.include?(status)
+
+    def terminal?(status) = TERMINAL.include?(status)
+  end
+end

data/lib/flexiq/workflow_run.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # A workflow run as the server reports it. `state` is a FlexiQ::WorkflowState symbol, or the
+  # raw wire value when this build does not know it. Timestamps are `Time` (UTC) or nil.
+  # `parent_run_id` / `parent_node_name` are set only on a sub-workflow's run.
+  WorkflowRun = Data.define(
+    :id, :definition_id, :state, :created_at, :started_at, :completed_at, :error,
+    :parent_run_id, :parent_node_name
+  ) do
+    def self.from_json(json)
+      new(
+        id: json["id"], definition_id: json["definitionId"], state: WorkflowState.load(json["state"]),
+        created_at: Wire::Timestamp.load(json["createdAt"]),
+        started_at: Wire::Timestamp.load(json["startedAt"]),
+        completed_at: Wire::Timestamp.load(json["completedAt"]),
+        error: json["error"], parent_run_id: json["parentRunId"], parent_node_name: json["parentNodeName"]
+      )
+    end
+
+    # Finished for good. An unrecognised state is never terminal.
+    def terminal? = WorkflowState.terminal?(state)
+  end
+end

data/lib/flexiq/workflow_run_view.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # What `Client#get_workflow_run` returns: the run and every node it has, in no set order.
+  WorkflowRunView = Data.define(:run, :nodes) do
+    def self.from_json(json)
+      run = json["run"]
+      raise TransportError, "the server answered without a workflow run" unless run.is_a?(Hash)
+
+      nodes = json.fetch("nodes", [])
+      raise TransportError, "the server answered a run whose nodes are not a list" unless nodes.is_a?(Array)
+
+      new(run: WorkflowRun.from_json(run), nodes: nodes.map { |node| WorkflowNodeState.from_json(node) }.freeze)
+    end
+
+    # The node named `name`, or nil.
+    def node(name) = nodes.find { |node| node.name == name }
+  end
+end

data/lib/flexiq/workflow_state.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FlexiQ
+  # `WorkflowState` as symbols. An unknown value stays raw and is never terminal: reading a
+  # newer server's state as finished would stop a poller watching a run that is still going.
+  module WorkflowState
+    BY_WIRE_NAME = {
+      "WORKFLOW_STATE_PENDING" => :pending,
+      "WORKFLOW_STATE_RUNNING" => :running,
+      "WORKFLOW_STATE_PAUSED" => :paused,
+      "WORKFLOW_STATE_COMPLETED" => :completed,
+      "WORKFLOW_STATE_COMPLETED_WITH_FAILURES" => :completed_with_failures,
+      "WORKFLOW_STATE_FAILED" => :failed,
+      "WORKFLOW_STATE_CANCELLED" => :cancelled,
+      "WORKFLOW_STATE_COMPENSATING" => :compensating,
+      "WORKFLOW_STATE_COMPENSATED" => :compensated,
+      "WORKFLOW_STATE_COMPENSATION_FAILED" => :compensation_failed
+    }.freeze
+
+    KNOWN = BY_WIRE_NAME.values.freeze
+    TERMINAL = %i[completed completed_with_failures failed cancelled compensated compensation_failed].freeze
+
+    module_function
+
+    def load(value) = BY_WIRE_NAME.fetch(value, value)
+
+    def known?(state) = KNOWN.include?(state)
+
+    def terminal?(state) = TERMINAL.include?(state)
+  end
+end

data/lib/flexiq.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# FlexiQ producer client over a flexiq-server's JSON door.
+# The wire contract is contracts/REMOTE_SDK_CONTRACT.md in the FlexiQ repository.
+
+require_relative "flexiq/version"
+require_relative "flexiq/errors"
+require_relative "flexiq/deadline"
+
+require_relative "flexiq/cbor/encoder"
+require_relative "flexiq/cbor/decoder"
+require_relative "flexiq/payload"
+
+require_relative "flexiq/wire/bytes"
+require_relative "flexiq/wire/duration"
+require_relative "flexiq/wire/int64"
+require_relative "flexiq/wire/path"
+require_relative "flexiq/wire/sse"
+require_relative "flexiq/wire/timestamp"
+
+require_relative "flexiq/reason"
+require_relative "flexiq/rpc_error"
+
+require_relative "flexiq/job_status"
+require_relative "flexiq/task_error"
+require_relative "flexiq/job"
+require_relative "flexiq/job_page"
+require_relative "flexiq/debounce"
+require_relative "flexiq/enqueue_options"
+require_relative "flexiq/enqueue_request"
+require_relative "flexiq/enqueue_result"
+require_relative "flexiq/batch_item_result"
+require_relative "flexiq/queue_stats"
+require_relative "flexiq/transition_kind"
+require_relative "flexiq/job_transition"
+require_relative "flexiq/watch_items"
+require_relative "flexiq/edge_condition"
+require_relative "flexiq/workflow_edge"
+require_relative "flexiq/workflow_constructs"
+require_relative "flexiq/workflow_node"
+require_relative "flexiq/workflow_graph"
+require_relative "flexiq/workflow_state"
+require_relative "flexiq/workflow_node_status"
+require_relative "flexiq/workflow_run"
+require_relative "flexiq/workflow_node_state"
+require_relative "flexiq/workflow_run_view"
+
+require_relative "flexiq/backoff"
+require_relative "flexiq/transport"
+require_relative "flexiq/watch"
+require_relative "flexiq/watch/by_ids"
+require_relative "flexiq/watch/by_queue"
+require_relative "flexiq/client"

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: flexiq
+version: !ruby/object:Gem::Version
+  version: 2.1.0
+platform: ruby
+authors:
+- ByteVeda
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Submit, read, cancel and count FlexiQ jobs over a running flexiq-server's
+  JSON door. Pure Ruby, standard library only: no database credential, no
+  native extension, no gRPC toolchain.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/flexiq.rb
+- lib/flexiq/backoff.rb
+- lib/flexiq/batch_item_result.rb
+- lib/flexiq/cbor/decoder.rb
+- lib/flexiq/cbor/encoder.rb
+- lib/flexiq/client.rb
+- lib/flexiq/deadline.rb
+- lib/flexiq/debounce.rb
+- lib/flexiq/edge_condition.rb
+- lib/flexiq/enqueue_options.rb
+- lib/flexiq/enqueue_request.rb
+- lib/flexiq/enqueue_result.rb
+- lib/flexiq/errors.rb
+- lib/flexiq/job.rb
+- lib/flexiq/job_page.rb
+- lib/flexiq/job_status.rb
+- lib/flexiq/job_transition.rb
+- lib/flexiq/payload.rb
+- lib/flexiq/queue_stats.rb
+- lib/flexiq/reason.rb
+- lib/flexiq/rpc_error.rb
+- lib/flexiq/task_error.rb
+- lib/flexiq/transition_kind.rb
+- lib/flexiq/transport.rb
+- lib/flexiq/version.rb
+- lib/flexiq/watch.rb
+- lib/flexiq/watch/by_ids.rb
+- lib/flexiq/watch/by_queue.rb
+- lib/flexiq/watch_items.rb
+- lib/flexiq/wire/bytes.rb
+- lib/flexiq/wire/duration.rb
+- lib/flexiq/wire/int64.rb
+- lib/flexiq/wire/path.rb
+- lib/flexiq/wire/sse.rb
+- lib/flexiq/wire/timestamp.rb
+- lib/flexiq/workflow_constructs.rb
+- lib/flexiq/workflow_edge.rb
+- lib/flexiq/workflow_graph.rb
+- lib/flexiq/workflow_node.rb
+- lib/flexiq/workflow_node_state.rb
+- lib/flexiq/workflow_node_status.rb
+- lib/flexiq/workflow_run.rb
+- lib/flexiq/workflow_run_view.rb
+- lib/flexiq/workflow_state.rb
+homepage: https://github.com/ByteVeda/flexiq
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ByteVeda/flexiq
+  source_code_uri: https://github.com/ByteVeda/flexiq/tree/master/sdks/ruby
+  documentation_uri: https://docs.byteveda.org/flexiq/server/clients
+  bug_tracker_uri: https://github.com/ByteVeda/flexiq/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby client for the FlexiQ producer door
+test_files: []