cloudmunda 0.1.0 → 0.1.3

data/lib/cloudmunda/cli/launcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'supervisor'
+
+module Cloudmunda
+  class Launcher
+    attr_reader :supervisor
+
+    def initialize
+      @supervisor = ::Cloudmunda::Supervisor.new
+    end
+
+    # Starts the supervisor and job processors.
+    def start
+      supervisor.start
+    end
+
+    # Tells the supervisor to stop processing any more jobs.
+    def quiet
+      supervisor.quiet
+    end
+
+    # Tells the supervisor to stop job processors. This method blocks until
+    # all processors are complete and stopped. It can take up to configurable
+    # timeout.
+    def stop
+      supervisor.stop
+    end
+
+    private
+
+    def client
+      ::Cloudmunda.client
+    end
+  end
+end

data/lib/cloudmunda/cli/processor.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Cloudmunda
+  class Processor
+    attr_reader :client, :worker_class, :busy_count, :timer
+
+    def initialize(worker_class:, client: ::Cloudmunda.client)
+      @client = client
+      @worker_class = worker_class
+      @busy_count = ::Concurrent::AtomicFixnum.new(0)
+      @timer = ::Concurrent::TimerTask.new(
+        run_now: true,
+        execution_interval: worker_poll_interval,
+        timeout_interval: worker_timeout
+      ) { run }
+    end
+
+    def start
+      timer.execute
+      self
+    end
+
+    def stop
+      timer.shutdown
+      self
+    end
+
+    def should_activate_jobs?
+      busy_count.value <= worker_max_jobs_to_activate
+    end
+
+    private
+
+    def run
+      fetch if should_activate_jobs?
+    end
+
+    def fetch
+      activate_jobs_request.each do |response|
+        busy_count.increment(response.jobs.count)
+        response.jobs.each do |job|
+          ::Concurrent::Future.execute do
+            process(job)
+          end
+        end
+      end
+    end
+
+    def process(job)
+      worker = worker_class.new(client)
+      begin
+        logger.info "class=#{worker_class} jid=#{job.key} Start processing #{job.type}"
+
+        worker.process(job)
+        worker.complete_job(job)
+
+        logger.info "class=#{worker_class} jid=#{job.key} Done processing #{job.type}"
+      rescue StandardError => e
+        logger.info "class=#{worker_class} jid=#{job.key} Failed processing #{job.type}: #{e.message}"
+
+        worker.fail_job(job, reason: e.message)
+        raise e
+      ensure
+        busy_count.decrement
+      end
+    end
+
+    def activate_jobs_request
+      client.activate_jobs(
+        type: worker_type,
+        worker: worker_name,
+        timeout: worker_timeout * 1000,
+        maxJobsToActivate: max_jobs_to_activate,
+        fetchVariable: worker_variables_to_fetch
+      )
+    end
+
+    def worker_type
+      worker_class.get_type
+    end
+
+    def worker_name
+      worker_class.get_name
+    end
+
+    def worker_max_jobs_to_activate
+      worker_class.get_max_jobs_to_activate
+    end
+
+    def worker_timeout
+      worker_class.get_timeout
+    end
+
+    def worker_variables_to_fetch
+      worker_class.get_variables_to_fetch
+    end
+
+    def worker_poll_interval
+      worker_class.get_poll_interval
+    end
+
+    def max_jobs_to_activate
+      worker_max_jobs_to_activate - busy_count.value
+    end
+
+    def logger
+      ::Cloudmunda.logger
+    end
+  end
+end

data/lib/cloudmunda/cli/supervisor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'processor'
+
+module Cloudmunda
+  class Supervisor
+    def initialize
+      @processors = []
+    end
+
+    def start
+      workers.each do |worker_class|
+        if ::Cloudmunda.env == 'development' && !worker_class.get_runs_in_development
+          logger.info "Not starting a processor for worker #{worker_class.get_type} as it doesn't run in development."
+          next
+        end
+
+        logger.info "Starting a processor for worker #{worker_class.get_type}"
+        processor = ::Cloudmunda::Processor.new(worker_class: worker_class)
+        @processors << processor.start
+      end
+    end
+
+    def quiet
+      logger.info 'Terminating workers'
+      @processors.each(&:stop)
+    end
+
+    def stop(timeout: ::Cloudmunda.timeout)
+      quiet
+      logger.info "Pausing #{timeout}s to allow workers to finish..."
+      sleep timeout
+    end
+
+    private
+
+    def workers
+      ::Cloudmunda.workers.to_a
+    end
+
+    def logger
+      ::Cloudmunda.logger
+    end
+  end
+end

data/lib/cloudmunda/cli/worker.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Cloudmunda
+  module Worker
+    attr_accessor :client, :type, :max_jobs_to_activate, :poll_interval, :timeout, :variables, :runs_in_development
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      Cloudmunda.register_worker(base)
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    def complete_job(job, variables: {})
+      logger.info "Completed processing job #{job.type} #{job.key}"
+      client.complete_job(
+        jobKey: job.key,
+        variables: Hash(variables).to_json
+      )
+    end
+
+    def fail_job(job, reason: '')
+      logger.error "Failed processing job #{job.type} #{job.key}: #{reason}"
+      client.fail_job(
+        jobKey: job.key,
+        retries: job.retries - 1,
+        errorMessage: reason
+      )
+    rescue StandardError => e
+      logger.error e.message
+    end
+
+    def logger
+      ::Cloudmunda.logger
+    end
+
+    module ClassMethods
+      # Sets the type of service task the worker should subscribe to.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Cloudmunda::Worker
+      #     type "some-service-task-type"
+      #   end
+      #
+      # @param [String] type
+      # @return [String]
+      def type(type)
+        @type = type
+      end
+
+      # Returns the type of service task the worker should subscribe to.
+      #
+      # @return [String]
+      def get_type
+        @type
+      end
+
+      # Sets the maximum number of jobs to send to the worker for processing at once.
+      # As jobs get completed by the worker, more jobs will be sent to the worker
+      # but always within this limit.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Cloudmunda::Worker
+      #     max_jobs_to_activate 5
+      #   end
+      #
+      # @param [Integer] max_jobs_to_activate
+      # @return [Integer]
+      def max_jobs_to_activate(max_jobs_to_activate)
+        @max_jobs_to_activate = max_jobs_to_activate
+      end
+
+      # Returns the maximum number of jobs to send to the worker for processing at once.
+      # As jobs get completed by the worker, more jobs will be sent to the worker
+      # but always within this limit.
+      #
+      # @return [Integer]
+      def get_max_jobs_to_activate
+        @max_jobs_to_activate || 1
+      end
+
+      # Sets the interval duration in seconds between polls to the broker.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Cloudmunda::Worker
+      #     poll_interval 5
+      #   end
+      #
+      # @param [Integer] poll_interval
+      # @return [Integer]
+      def poll_interval(poll_interval)
+        @poll_interval = poll_interval
+      end
+
+      # Returns the interval duration in seconds between polls to the broker.
+      #
+      # @return [Integer]
+      def get_poll_interval
+        @poll_interval || 5
+      end
+
+      # Sets the time in seconds the worker has to process the job before
+      # the broker consider it as expired and can schedule it to another worker.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Cloudmunda::Worker
+      #     timeout 30
+      #   end
+      #
+      # @param [Integer] timeout
+      # @return [Integer]
+      def timeout(timeout)
+        @timeout = timeout
+      end
+
+      # Returns the time in seconds the worker has to process the job before
+      # the broker consider it as expired and can schedule it to another worker.
+      #
+      # @return [Integer]
+      def get_timeout
+        @timeout || 30
+      end
+
+      # Sets the worker's variables to fetch from the broker when polling for new
+      # jobs.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Cloudmunda::Worker
+      #     variables [:foo, :bar]
+      #   end
+      #
+      # @param [Array<String, Symbol>] variables
+      # @return [Array<String, Symbol>]
+      def variables(variables)
+        @variables = variables
+      end
+
+      # Returns the worker's variables to fetch from the broker when polling for new
+      # jobs.
+      #
+      # @return [Array<String, Symbol>]
+      def get_variables_to_fetch
+        @variables.to_a
+      end
+
+      # Sets if this service task runs in development mode or not.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Cloudmunda::Worker
+      #     runs_in_development true
+      #   end
+      #
+      # @param [Boolean] runs_in_development
+      # @return [Boolean]
+      def runs_in_development(runs_in_development)
+        @runs_in_development = runs_in_development
+      end
+
+      # Returns if this service task should run in development mode.
+      #
+      # @return [Boolean]
+      def get_runs_in_development
+        @runs_in_development || false
+      end
+
+      # Returns the worker's name.
+      #
+      # @return [String]
+      def get_name
+        name = self.name.gsub(/::/, ':')
+        name.gsub!(/([^A-Z:])([A-Z])/) { "#{Regexp.last_match(1)}_#{Regexp.last_match(2)}" }
+        name.downcase
+      end
+    end
+  end
+end

data/lib/cloudmunda/cli.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'optparse'
+require 'fileutils'
+require 'cloudmunda'
+require 'cloudmunda/cli/launcher'
+
+$stdout.sync = true
+
+module Cloudmunda
+  class CLI
+    include Singleton
+
+    attr_accessor :launcher
+
+    def parse(argv = ARGV)
+      parse_options(argv)
+    end
+
+    def run
+      boot
+
+      self_read, self_write = IO.pipe
+      sigs = %w[INT TERM]
+      sigs.each do |sig|
+        trap sig do
+          self_write.write("#{sig}\n")
+        end
+      rescue ArgumentError
+        logger.warn "Signal #{sig} not supported"
+      end
+
+      launch(self_read)
+    end
+
+    private
+
+    def parse_options(argv)
+      option_parser.parse!(argv)
+    end
+
+    def option_parser
+      OptionParser.new.tap do |p|
+        p.on '-e', '--env ENV', 'Application environment' do |arg|
+          config.env = arg
+        end
+
+        p.on '-i', '--client-id CLIENT_ID', 'Client ID' do |arg|
+          config.client_id = arg
+        end
+
+        p.on '-r', '--require [PATH|DIR]', 'Location of Rails application with workers or file to require' do |arg|
+          if !File.exist?(arg) ||
+             (File.directory?(arg) && !File.exist?("#{arg}/config/application.rb"))
+            raise ArgumentError, "#{arg} is not a ruby file nor a rails application"
+          else
+            config.require = arg
+          end
+        end
+
+        p.on '-s', '--client-secret CLIENT_SECRET', 'Client Secret' do |arg|
+          config.client_secret = arg
+        end
+
+        p.on '-u', '--zeebe-url ZEEBE_URL', 'Zeebe URL' do |arg|
+          config.zeebe_url = arg
+        end
+
+        p.on '-U', '--zeebe-auth-url ZEEBE_AUTH_URL', 'Zeebe Authorization Server URL' do |arg|
+          config.auth_url = arg
+        end
+
+        p.on '-a', '--audience URL', 'Zeebe Audience' do |arg|
+          config.audience = arg
+        end
+
+        p.on '-T', '--use-access-token STRING', 'Zeebe Audience' do |arg|
+          config.use_access_token = arg.to_s.downcase == 'true'
+        end
+
+        p.on '-t', '--timeout NUM', 'Shutdown timeout' do |arg|
+          timeout = Integer(arg)
+          raise ArgumentError, 'timeout must be a positive integer' if timeout <= 0
+
+          config.timeout = timeout
+        end
+
+        # p.on "-v", "--verbose", "Print more verbose output" do |arg|
+        #   ::Cloudmuna.logger.level = ::Logger::DEBUG
+        # end
+
+        p.on '-V', '--version', 'Print version and exit' do |_arg|
+          puts "Cloudmunda #{::Cloudmunda::VERSION}"
+          exit(0)
+        end
+
+        p.banner = 'Usage: cloudmunda [options]'
+        p.on_tail '-h', '--help', 'Show help' do
+          puts p
+
+          exit(1)
+        end
+      end
+    end
+
+    def boot
+      ENV['RACK_ENV'] = ENV['RAILS_ENV'] = config.env
+
+      if File.directory?(config.require)
+        require 'rails'
+        raise 'Cloudmunda does not supports this version of Rails' if ::Rails::VERSION::MAJOR < 6
+
+        require File.expand_path("#{config.require}/config/environment.rb")
+        Dir[Rails.root.join('app/jobs/**/*.rb')].sort.each { |f| require f }
+
+        logger.info "Booted Rails #{::Rails.version} application in #{config.env} environment"
+      else
+        require config.require
+      end
+    end
+
+    def launch(self_read)
+      @launcher = ::Cloudmunda::Launcher.new
+
+      logger.info 'Starting processing, hit Ctrl-C to stop' if config.env == 'development' && $stdout.tty?
+
+      begin
+        launcher.start
+
+        while (readable_io = IO.select([self_read]))
+          signal = readable_io.first[0].gets.strip
+          handle_signal(signal)
+        end
+      rescue Interrupt
+        logger.info 'Shutting down'
+        launcher.stop
+        logger.info 'Bye!'
+
+        exit(0)
+      end
+    end
+
+    def handle_signal(signal)
+      handler = signal_handlers[signal]
+      if handler
+        handler.call(self)
+      else
+        logger.warn "No signal handler for #{signal}"
+      end
+    end
+
+    def signal_handlers
+      {
+        'INT' => ->(_cli) { raise Interrupt },
+        'TERM' => ->(_cli) { raise Interrupt }
+      }
+    end
+
+    def config
+      ::Cloudmunda
+    end
+
+    def logger
+      ::Cloudmunda.logger
+    end
+  end
+end

data/lib/cloudmunda/configuration.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Cloudmunda
+  module Configuration
+    VALID_OPTIONS_KEYS = %i[env require logger timeout zeebe_url auth_url client_id client_secret audience
+                            graphql_url].freeze
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    # Sets all configuration options to their default values when this module is extended.
+    def self.extended(base)
+      base.reset
+    end
+
+    def configure
+      yield self
+    end
+
+    def config
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    # Resets all configuration options to the defaults.
+    def reset
+      @env = ENV['APP_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      @logger = Logger.new($stdout)
+      @require = '.'
+      @timeout = @env == 'development' ? 5 : 30
+      @zeebe_url = ENV['ZEEBE_URL']
+      @auth_url = ENV['ZEEBE_AUTHORIZATION_SERVER_URL']
+      @client_id = ENV['ZEEBE_CLIENT_ID']
+      @client_secret = ENV['ZEEBE_CLIENT_SECRET']
+      @audience = ENV['ZEEBE_AUDIENCE']
+      @graphql_url = ENV['GRAPHQL_URL']
+    end
+  end
+end

data/lib/cloudmunda/graphql/client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+require 'uri'
+require 'base64'
+
+module Cloudmunda
+  module Graphql
+    class Client
+      def self.post(params = {})
+        response = RestClient.post(Cloudmunda.graphql_url, params.to_json, headers.merge(content_headers))
+        JSON.parse(response.body)
+      end
+
+      def self.headers
+        access_token = Cloudmunda::API::AccessToken.create(audience_url: 'tasklist.camunda.io').access_token
+        {
+          authorization: "Bearer #{access_token}"
+        }
+      end
+
+      def self.content_headers
+        {
+          'Content-Type': 'application/json'
+        }
+      end
+    end
+  end
+end

data/lib/cloudmunda/graphql/user_tasks.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Cloudmunda
+  module Graphql
+    class UserTasks
+      def self.all
+        query = "{
+          tasks(query: { state: CREATED })
+          {
+            id
+            taskDefinitionId
+            name
+            taskState
+            assignee
+            taskState
+            isFirst
+            formKey
+            processDefinitionId
+            completionTime
+            processName
+            variables {
+              name
+              value
+            }
+          }
+        }"
+        Cloudmunda::Graphql::Client.post(query: query)['data']['tasks']
+      end
+
+      def self.run_mutation(mutation)
+        Cloudmunda::Graphql::Client.post(query: mutation)
+      end
+    end
+  end
+end

data/lib/cloudmunda/graphql.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'graphql/client'
+require_relative 'graphql/user_tasks'

data/lib/cloudmunda/loggable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cloudmunda
+  module Loggable
+    def logger
+      @logger || setup_logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def setup_logger
+      @logger = Beez.config.logger
+    end
+  end
+end

data/lib/cloudmunda/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cloudmunda
-  VERSION = "0.1.0"
+  VERSION = '0.1.3'
 end