qyu 1.0.0

data/lib/qyu/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Qyu
+  # Qyu::Config
+  class Config
+    attr_reader :queue, :store
+
+    class ServiceConfig
+      class << self
+        def register(adapter_class)
+          types[adapter_class::TYPE] = adapter_class
+        end
+
+        def valid?(config)
+          types[config[:type]].valid_config?(config)
+        end
+
+        def types
+          @__types ||= {}
+        end
+      end
+    end
+
+    class QueueConfig < ServiceConfig; end
+    class StoreConfig < ServiceConfig; end
+
+    def initialize(queue:, store:)
+      fail 'Invalid message queue configuration' unless QueueConfig.valid?(queue)
+      fail 'Invalid state store configuration' unless StoreConfig.valid?(store)
+
+      @queue = queue
+      @store = store
+    end
+  end
+end

data/lib/qyu/errors.rb

@@ -0,0 +1,4 @@
+require 'qyu/errors/base'
+(Dir["#{File.dirname(__FILE__)}/errors/*.rb"]).each do |path|
+  require path
+end

data/lib/qyu/errors/base.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::Base
+    class Base < ::StandardError; end
+  end
+end

data/lib/qyu/errors/could_not_fetch_task.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::CouldNotFetchTask
+    # TODO: rethink this...
+    class CouldNotFetchTask < Base
+      attr_reader :original_error, :queue_name, :message_id, :task_id
+      def initialize(queue_name, message_id, task_id, original_error)
+        super("Task cannot be fetched from queue=#{queue_name} with message_id=#{message_id} task_id=#{task_id}.")
+        @original_error = original_error
+        @task_id = task_id
+        @message_id = message_id
+        @queue_name = queue_name
+      end
+    end
+  end
+end

data/lib/qyu/errors/invalid_queue_name.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::InvalidQueueName
+    class InvalidQueueName < Base
+      def initialize
+        super('Queue name is invalid.')
+      end
+    end
+  end
+end

data/lib/qyu/errors/invalid_task_attributes.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::InvalidTaskAttributes
+    class InvalidTaskAttributes < Base
+      def initialize
+        super('Invalid task attributes.')
+      end
+    end
+  end
+end

data/lib/qyu/errors/job_not_found.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::JobNotFound
+    class JobNotFound < Base
+      attr_reader :original_error
+      def initialize(id, original_error)
+        super("Job not found with id=#{id}.")
+        @original_error = original_error
+      end
+    end
+  end
+end

data/lib/qyu/errors/lock_already_acquired.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::LockAlreadyAcquired
+    class LockAlreadyAcquired < Base
+      def initialize
+        super('Lock already acquired.')
+      end
+    end
+  end
+end

data/lib/qyu/errors/lock_not_acquired.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::LockNotAcquired
+    class LockNotAcquired < Base
+      def initialize
+        super('Lock was not acquired.')
+      end
+    end
+  end
+end

data/lib/qyu/errors/message_not_received.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::MessageNotReceived
+    class MessageNotReceived < Base
+      def initialize
+        super('No message retrieved for task from queue.')
+      end
+    end
+  end
+end

data/lib/qyu/errors/not_implemented_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::NotImplementedError
+    class NotImplementedError < Base
+      def initialize
+        super('Abstract method. Should have been overwritten.')
+      end
+    end
+  end
+end

data/lib/qyu/errors/payload_validation_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::PayloadValidationError
+    class PayloadValidationError < Base
+      def initialize(validation_errors_hash)
+        super("Validation failed for payload fields: #{validation_errors_hash}.")
+      end
+    end
+  end
+end

data/lib/qyu/errors/task_not_found.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::TaskNotFound
+    class TaskNotFound < Base
+      attr_reader :task_id, :original_error
+      def initialize(task_id, original_error)
+        super("Task not found with id=#{task_id}.")
+        @original_error = original_error
+        @task_id = task_id
+      end
+    end
+  end
+end

data/lib/qyu/errors/task_status_update_failed.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::TaskStatusUpdateFailed
+    class TaskStatusUpdateFailed < Base
+      attr_reader :task_id, :status
+      def initialize(task_id, status)
+        super("Task status cannot be updated task_id=#{task_id} status=#{status}.")
+        @task_id = task_id
+        @status = status
+      end
+    end
+  end
+end

data/lib/qyu/errors/unknown_validation_option.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::UnknownValidationOption
+    class UnknownValidationOption < Base
+      def initialize(option)
+        super("Validation option #{option} is unknown")
+      end
+    end
+  end
+end

data/lib/qyu/errors/unsync_error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::InvalidQueueName
+    class UnsyncError < Base
+      def initialize
+        super('Not all tasks have been started yet')
+      end
+    end
+  end
+end

data/lib/qyu/errors/workflow_descriptor_validation_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::WorkflowDescriptorValidatorationError
+    class WorkflowDescriptorValidatorationError < Base
+      attr_reader :validation_errors
+      def initialize(validation_errors)
+        super('Invalid Job descriptor.')
+        @validation_errors = validation_errors
+      end
+    end
+  end
+end

data/lib/qyu/errors/workflow_not_found.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Errors
+    # Qyu::Errors::WorkflowNotFound
+    class WorkflowNotFound < Base
+      attr_reader :key, :workflow_id
+      def initialize(key, workflow_id)
+        super("Workflow not found with #{key}=#{workflow_id}.")
+        @key = key
+        @workflow_id = workflow_id
+      end
+    end
+  end
+end

data/lib/qyu/factory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Qyu
+  # Qyu::Factory
+  class Factory
+    class ServiceFactory
+      class << self
+        def register(adapter_class)
+          types[adapter_class::TYPE] = adapter_class
+        end
+
+        def types
+          @__types ||= {}
+        end
+
+        def get(config)
+          Qyu.logger.info "Got factory #{types[config[:type]]}"
+          types[config[:type]].new(config)
+        end
+      end
+    end
+
+    class QueueFactory < ServiceFactory; end
+    class StoreFactory < ServiceFactory; end
+  end
+end

data/lib/qyu/models.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+(
+  Dir["#{File.dirname(__FILE__)}/models/concerns/*.rb"] +
+  Dir["#{File.dirname(__FILE__)}/models/*.rb"] +
+  Dir["#{File.dirname(__FILE__)}/models/enums/*.rb"]
+).each do |path|
+  require path
+end

data/lib/qyu/models/concerns/workflow_descriptor_validator.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Qyu
+  module Concerns
+    # Qyu::Concerns::WorkflowDescriptorValidator
+    class WorkflowDescriptorValidator
+      ALLOWED_KEYS = %w(queue waits_for starts starts_manually starts_with_params).freeze
+      attr_reader :errors
+
+      def initialize(descriptor)
+        @descriptor = descriptor
+        @errors = []
+      end
+
+      def valid?
+        validate
+        @errors.empty?
+      end
+
+      def validate
+        @errors << 'Descriptor type must be a Hash.' unless validate_descriptor_type
+        @errors << 'Entry points (starts) must be an Array.' unless validate_entry_points_type
+        @errors << 'Tasks must be a Hash.' unless validate_tasks_type
+        unless validate_entry_points_presence
+          @errors << 'There must be at least 1 entry point, and all entry points must exist in the tasks Hash.'
+        end
+        @errors << 'There must be at least 1 task in the tasks Hash.' unless validate_tasks_presence
+
+        tasks.keys.each do |task_name|
+          unless validate_queue_presence(task_name)
+            @errors << "#{task_name} must have a valid queue."
+          end
+          unless validate_task_keys(task_name)
+            @errors << "#{task_name} must only contain the following keys: #{ALLOWED_KEYS}."
+          end
+          unless validate_task_reference_formats(task_name)
+            @errors << "#{task_name} must follow the reference declaration format."
+          end
+          unless validate_task_references(task_name)
+            @errors << "#{task_name} must list existing tasks in its references."
+          end
+          unless validate_sync_condition_params(task_name)
+            @errors << "#{task_name} must pass the correct parameters to the sync task."
+          end
+        end
+      rescue => ex
+        Qyu.logger.error "Error while validation: #{ex.class}: #{ex.message}"
+        Qyu.logger.error "Backtrace: #{ex.backtrace.join("\n")}"
+        @errors << "#{ex.class}: #{ex.message}"
+      end
+
+      private
+
+      def validate_descriptor_type
+        @descriptor.is_a?(Hash)
+      end
+
+      def validate_entry_points_type
+        entry_points.is_a?(Array)
+      end
+
+      def validate_tasks_type
+        tasks.is_a?(Hash)
+      end
+
+      def validate_entry_points_presence
+        !entry_points.empty? && \
+          entry_points.all? { |task_name| tasks.keys.include?(task_name) }
+      end
+
+      def validate_tasks_presence
+        !tasks.empty?
+      end
+
+      def validate_queue_presence(task_name)
+        tasks[task_name]['queue'].is_a?(String)
+      end
+
+      def validate_task_keys(task_name)
+        tasks[task_name].keys.all? { |key| ALLOWED_KEYS.include?(key) }
+      end
+
+      def validate_task_reference_formats(task_name)
+        (tasks[task_name]['starts'].nil? || tasks[task_name]['starts'].is_a?(Array)) &&
+          (tasks[task_name]['starts_manually'].nil? || tasks[task_name]['starts_manually'].is_a?(Array)) &&
+          (tasks[task_name]['starts_with_params'].nil? || tasks[task_name]['starts_with_params'].is_a?(Hash))
+        (tasks[task_name]['waits_for'].nil? || tasks[task_name]['waits_for'].is_a?(Hash))
+      end
+
+      def validate_task_references(task_name)
+        (tasks[task_name]['starts'] || []).all? { |t_name| tasks[t_name].is_a?(Hash) } &&
+          (tasks[task_name]['starts_manually'] || []).all? { |t_name| tasks[t_name].is_a?(Hash) } &&
+          (tasks[task_name]['starts_with_params'] || {}).all? { |t_name, _| tasks[t_name].is_a?(Hash) }
+        (tasks[task_name]['waits_for'] || {}).all? { |t_name, _| tasks[t_name].is_a?(Hash) }
+      end
+
+      def validate_sync_condition_params(task_name)
+        return true unless tasks[task_name]['starts_with_params']
+        tasks[task_name]['starts_with_params'].all? do |started_task_name, params_config|
+          params_config.all? do |param_name, _param_config|
+            tasks[started_task_name]['waits_for'].detect do |_t_name, sync_config|
+              sync_config['condition']['param'] == param_name
+            end
+          end
+        end
+      end
+
+      def entry_points
+        @descriptor['starts']
+      end
+
+      def tasks
+        @descriptor['tasks']
+      end
+    end
+  end
+end

data/lib/qyu/models/enums/status.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Qyu
+  class Status
+    COMPLETED       = 'completed'
+    QUEUED          = 'queued'
+    WORKING         = 'working'
+    FAILED          = 'failed'
+    INVALID_PAYLOAD = 'invalid_payload'
+
+    def self.find(id)
+      Qyu.store.find_task(@id)
+    end
+
+    def initialize(id)
+      @id = id
+    end
+
+    def status
+      t = Qyu.store.find_task(@id)
+      t['status']
+    end
+
+    def completed?
+      status == COMPLETED
+    end
+
+    def queued?
+      status == QUEUED
+    end
+
+    def working?
+      status == WORKING
+    end
+
+    def failed?
+      status == FAILED
+    end
+
+    def invalid_payload?
+      status == INVALID_PAYLOAD
+    end
+  end
+end