cloudmunda 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0224d338965547c5fb715c3e3b3f6443606fe3688ecf3bef13c7fedd10ded234
-  data.tar.gz: ba347d1a7aa1624624d30d3459110c81e0a6ff98e9e4d06dfb9c9c08e7d75dd3
+  metadata.gz: '0882dcb50d23ad283984404e67f589a28d39a08c19ec44b9c2ca00659386962e'
+  data.tar.gz: 7d03f8ddd3c6cc8ba8a464e64e84a14234a791540f947a25cb94dd36fd5bc8c1
 SHA512:
-  metadata.gz: 72ce642c5be6dc2a8d12585c88aaa8c89f9ac6a8d89ee7ae83f0dae71788689b6f09cbbce4543582c1f1af734045dc230b44bb33041d7a57cd7e705611df9625
-  data.tar.gz: 49d5cf58b015e80c233eebb989a0c855fcd59b91a252aaf91e7bf127c068ad027eb119a491284e769b1be04518234c7506f353ddd6e6fb093f84a79c0195a04b
+  metadata.gz: 1aa60b038071944496032564eb73a21c3344211ab4339cc77d9d74de6ecaf7814e31eb69fafada0cd6f25432f9e4a85f2cf9003edf209735605986f9c5c26f9b
+  data.tar.gz: 5e5d47130dc95f8d98a12facaf4dc8830cded1f3420e3b96df838d5730c01339dd0187177d9f5d92c6c1ac175b67d647530dc497383686eda2d46a16cba57355

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.1.1] - 2021-12-16
+
+- Camunda Cloud Access Token Creation
+- Zeebe task workers
+- Camunda Cloud Usertasks graphQL connection
+
 ## [0.1.0] - 2021-12-16
 
 - Initial release
+_

data/Gemfile

@@ -5,8 +5,7 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in cloudmunda.gemspec
 gemspec
 
+gem "rails", ">= 6"
 gem "rake", "~> 13.0"
-
 gem "rspec", "~> 3.0"
-
 gem "rubocop", "~> 1.21"

data/Gemfile.lock

@@ -1,19 +1,151 @@
 PATH
   remote: .
   specs:
-    cloudmunda (0.1.0)
+    cloudmunda (0.1.1)
+      concurrent-ruby (~> 1.0)
+      rest-client (~> 2.0)
+      zeebe-client (~> 0.16)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    actioncable (6.1.4.1)
+      actionpack (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (6.1.4.1)
+      actionpack (= 6.1.4.1)
+      activejob (= 6.1.4.1)
+      activerecord (= 6.1.4.1)
+      activestorage (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      mail (>= 2.7.1)
+    actionmailer (6.1.4.1)
+      actionpack (= 6.1.4.1)
+      actionview (= 6.1.4.1)
+      activejob (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (6.1.4.1)
+      actionview (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      rack (~> 2.0, >= 2.0.9)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (6.1.4.1)
+      actionpack (= 6.1.4.1)
+      activerecord (= 6.1.4.1)
+      activestorage (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      nokogiri (>= 1.8.5)
+    actionview (6.1.4.1)
+      activesupport (= 6.1.4.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (6.1.4.1)
+      activesupport (= 6.1.4.1)
+      globalid (>= 0.3.6)
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activestorage (6.1.4.1)
+      actionpack (= 6.1.4.1)
+      activejob (= 6.1.4.1)
+      activerecord (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      marcel (~> 1.0.0)
+      mini_mime (>= 1.1.0)
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     ast (2.4.2)
+    builder (3.2.4)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
     diff-lcs (1.4.4)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    erubi (1.10.0)
+    globalid (1.0.0)
+      activesupport (>= 5.0)
+    google-protobuf (3.19.1-x86_64-darwin)
+    googleapis-common-protos-types (1.3.0)
+      google-protobuf (~> 3.14)
+    grpc (1.42.0-x86_64-darwin)
+      google-protobuf (~> 3.18)
+      googleapis-common-protos-types (~> 1.0)
+    http-accept (1.7.0)
+    http-cookie (1.0.4)
+      domain_name (~> 0.5)
+    i18n (1.8.11)
+      concurrent-ruby (~> 1.0)
+    loofah (2.13.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mime-types (3.4.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2021.1115)
+    mini_mime (1.1.2)
+    minitest (5.14.4)
+    netrc (0.11.0)
+    nio4r (2.5.8)
+    nokogiri (1.12.5-x86_64-darwin)
+      racc (~> 1.4)
     parallel (1.21.0)
     parser (3.0.3.2)
       ast (~> 2.4.1)
+    racc (1.6.0)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails (6.1.4.1)
+      actioncable (= 6.1.4.1)
+      actionmailbox (= 6.1.4.1)
+      actionmailer (= 6.1.4.1)
+      actionpack (= 6.1.4.1)
+      actiontext (= 6.1.4.1)
+      actionview (= 6.1.4.1)
+      activejob (= 6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activerecord (= 6.1.4.1)
+      activestorage (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      bundler (>= 1.15.0)
+      railties (= 6.1.4.1)
+      sprockets-rails (>= 2.0.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
+    railties (6.1.4.1)
+      actionpack (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      method_source
+      rake (>= 0.13)
+      thor (~> 1.0)
     rainbow (3.0.0)
     rake (13.0.6)
     regexp_parser (2.2.0)
+    rest-client (2.1.0)
+      http-accept (>= 1.7.0, < 2.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
     rexml (3.2.5)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
@@ -40,13 +172,33 @@ GEM
     rubocop-ast (1.15.0)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
+    sprockets (4.0.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.4.1)
+      actionpack (>= 5.2)
+      activesupport (>= 5.2)
+      sprockets (>= 3.0.0)
+    thor (1.1.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.8)
     unicode-display_width (2.1.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeebe-client (0.16.0)
+      grpc (~> 1.32)
+    zeitwerk (2.5.1)
 
 PLATFORMS
   x86_64-darwin-20
 
 DEPENDENCIES
   cloudmunda!
+  rails (>= 6)
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop (~> 1.21)

data/README.md

@@ -22,7 +22,16 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+Cloudmunda.configure do |config|
+  config.env = ENV['APP_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+  config.require = '.'
+  config.timeout = 30
+  config.zeebe_url = ENV['ZEEBE_URL']
+  config.auth_url = ENV['ZEEBE_AUTHORIZATION_SERVER_URL']
+end
+```
+
 
 ## Development
 

data/exe/cloudmunda

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "cloudmunda/cli"
+
+begin
+  cli = ::Cloudmunda::CLI.instance
+  cli.parse
+  cli.run
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/lib/cloudmunda/api/access_token.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Cloudmunda
+  module API
+    class AccessToken < Cloudmunda::API::OAuthResource
+      def self.create(audience_url: Cloudmunda.audience)
+        uri = Cloudmunda.auth_url
+        payload = {
+          "grant_type":"client_credentials",
+          "audience": audience_url,
+          "client_id": Cloudmunda.client_id,
+          "client_secret": Cloudmunda.client_secret
+        }
+
+        create_by_uri(uri: uri, payload: payload)
+      end
+    end
+  end
+end

data/lib/cloudmunda/api/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+require 'uri'
+require 'base64'
+
+module Cloudmunda
+  module API
+    class Client
+      def self.post(url, params = {})
+        response = RestClient.post(url, params.to_json, headers.merge(content_headers))
+        JSON.parse(response.body)
+      end
+
+      def self.headers
+        {
+          authorization: "Basic " + Base64.strict_encode64("#{Cloudmunda.client_id}:#{Cloudmunda.client_secret}"),
+        }
+      end
+
+      def self.content_headers
+        {
+          'Content-Type': 'application/json'
+        }
+      end
+    end
+  end
+end

data/lib/cloudmunda/api/o_auth_resource.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Cloudmunda
+  module API
+    class OAuthResource < OpenStruct
+      def self.create_by_uri(uri:, payload:)
+        raw_item = Cloudmunda::API::Client.post(uri, payload)
+        raw_item = {} if raw_item == ""
+        new(raw_item)
+      end
+
+      def initialize(raw)
+        super(raw)
+      end
+    end
+  end
+end

data/lib/cloudmunda/api.rb

@@ -0,0 +1,4 @@
+require_relative 'api/o_auth_resource'
+require_relative 'api/access_token'
+require_relative 'api/client'
+

data/lib/cloudmunda/cli/launcher.rb

@@ -0,0 +1,35 @@
+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,109 @@
+module Cloudmunda
+  class Processor
+
+    attr_reader :client, :worker_class, :busy_count, :timer
+
+    def initialize(client: ::Cloudmunda.client, worker_class:)
+      @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 => exception
+        logger.info "class=#{worker_class} jid=#{job.key} Failed processing #{job.type}: #{exception.message}"
+
+        worker.fail_job(job, reason: exception.message)
+        raise exception
+      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,37 @@
+require_relative 'processor'
+
+module Cloudmunda
+  class Supervisor
+    def initialize
+      @processors = []
+    end
+
+    def start
+      @processors = workers.map do |worker_class|
+        processor = ::Cloudmunda::Processor.new(worker_class: worker_class)
+        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,163 @@
+require 'json'
+
+module Cloudmunda
+  module Worker
+    attr_accessor :client, :type, :max_jobs_to_activate, :poll_interval, :timeout, :variables
+
+    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 => 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
+
+      # Returns the worker's name.
+      #
+      # @return [String]
+      def get_name
+        name = self.name.gsub(/::/, ':')
+        name.gsub!(/([^A-Z:])([A-Z])/) { "#{$1}_#{$2}" }
+        name.downcase
+      end
+    end
+  end
+end

data/lib/cloudmunda/cli.rb

@@ -0,0 +1,169 @@
+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'
+        if ::Rails::VERSION::MAJOR < 6
+          raise "Cloudmunda does not supports this version of Rails"
+        else
+          require File.expand_path("#{config.require}/config/environment.rb")
+          Dir[Rails.root.join('app/jobs/**/*.rb')].each { |f| require f }
+
+          logger.info "Booted Rails #{::Rails.version} application in #{config.env} environment"
+        end
+      else
+        require config.require
+      end
+    end
+
+    def launch(self_read)
+      @launcher = ::Cloudmunda::Launcher.new
+
+      if config.env == "development" && $stdout.tty?
+        logger.info "Starting processing, hit Ctrl-C to stop"
+      end
+
+      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,35 @@
+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 = 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,29 @@
+# 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
+        {
+          authorization: "Bearer " + Cloudmunda::API::AccessToken.create(audience_url: 'tasklist.camunda.io').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,2 @@
+require_relative 'graphql/client'
+require_relative 'graphql/user_tasks'

data/lib/cloudmunda/loggable.rb

@@ -0,0 +1,15 @@
+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.1"
 end

data/lib/cloudmunda/zeebe/client.rb

@@ -0,0 +1,107 @@
+require 'zeebe/client'
+
+module Cloudmunda
+  module Zeebe
+    class Client
+
+      attr_reader :client
+
+      def initialize(url: ::Cloudmunda.zeebe_url)
+        @client = ::Zeebe::Client::GatewayProtocol::Gateway::Stub.new(url, authentication_headers)
+      end
+
+      def activate_jobs(params = {})
+        run(:activate_jobs,
+          ::Zeebe::Client::GatewayProtocol::ActivateJobsRequest.new(params)
+        )
+      end
+
+      def cancel_workflow_instance(params = {})
+        run(:cancel_workflow_instance,
+          ::Zeebe::Client::GatewayProtocol::CancelWorkflowInstanceRequest.new(params)
+        )
+      end
+
+      def complete_job(params = {})
+        run(:complete_job,
+          ::Zeebe::Client::GatewayProtocol::CompleteJobRequest.new(params)
+        )
+      end
+
+      def create_process_instance(params = {})
+        run(:create_process_instance,
+          ::Zeebe::Client::GatewayProtocol::CreateProcessInstanceRequest.new(params)
+        )
+      end
+
+      def deploy_process(params = {})
+        run(:deploy_process,
+          ::Zeebe::Client::GatewayProtocol::DeployProcessRequest.new(params)
+        )
+      end
+
+      def fail_job(params = {})
+        run(:fail_job,
+          ::Zeebe::Client::GatewayProtocol::FailJobRequest.new(params)
+        )
+      end
+
+      def throw_error(params = {})
+        run(:throw_error,
+          ::Zeebe::Client::GatewayProtocol::ThrowErrorRequest.new(params)
+        )
+      end
+
+      def publish_message(params = {})
+        run(:publish_message,
+          ::Zeebe::Client::GatewayProtocol::PublishMessageRequest.new(params)
+        )
+      end
+
+      def resolve_incident(params = {})
+        run(:resolve_incident,
+          ::Zeebe::Client::GatewayProtocol::ResolveIncidentRequest.new(params)
+        )
+      end
+
+      def set_variables(params = {})
+        run(:set_variables,
+          ::Zeebe::Client::GatewayProtocol::SetVariablesRequest.new(params)
+        )
+      end
+
+      def topology(params = {})
+        run(:topology,
+          ::Zeebe::Client::GatewayProtocol::TopologyRequest.new(params)
+        )
+      end
+
+      def update_job_retries(params = {})
+        run(:update_job_retries,
+          ::Zeebe::Client::GatewayProtocol::UpdateJobRetriesRequest.new(params)
+        )
+      end
+
+      private
+
+      def run(method, params = {})
+        client.public_send(method, params)
+      rescue ::GRPC::Unavailable => exception
+        logger.error exception.message
+        raise exception
+      end
+
+      def logger
+        # ::Cloudmunda.logger
+      end
+
+      def authentication_headers
+        token = Cloudmunda::API::AccessToken.create
+        channel_creds = GRPC::Core::ChannelCredentials.new()
+        auth_proc = proc { { 'authorization' => "Bearer #{token.access_token}" } }
+        call_creds = GRPC::Core::CallCredentials.new(auth_proc)
+        channel_creds.compose(call_creds)
+      end
+    end
+  end
+end

data/lib/cloudmunda/zeebe.rb

@@ -0,0 +1 @@
+require_relative 'zeebe/client'

data/lib/cloudmunda.rb

@@ -1,8 +1,28 @@
 # frozen_string_literal: true
 
+require 'concurrent'
+
 require_relative "cloudmunda/version"
+require_relative 'cloudmunda/loggable'
+require_relative 'cloudmunda/cli/worker'
+require_relative 'cloudmunda/configuration'
+require_relative 'cloudmunda/api'
+require_relative 'cloudmunda/zeebe'
+require_relative 'cloudmunda/graphql'
 
 module Cloudmunda
-  class Error < StandardError; end
-  # Your code goes here...
+  extend Configuration
+  extend Loggable
+
+  def self.client
+    @client ||= ::Cloudmunda::Zeebe::Client.new
+  end
+
+  def self.register_worker(worker)
+    self.workers << worker
+  end
+
+  def self.workers
+    @workers ||= []
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloudmunda
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Lien Van Den Steen
@@ -9,11 +9,54 @@ autorequire:
 bindir: exe
 cert_chain: []
 date: 2021-12-16 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: zeebe-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Ruby wrapper for Camunda Cloud
 email:
 - lienvandensteen@gmail.com
-executables: []
+executables:
+- cloudmunda
 extensions: []
 extra_rdoc_files: []
 files:
@@ -28,8 +71,25 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/cloudmunda
 - lib/cloudmunda.rb
+- lib/cloudmunda/api.rb
+- lib/cloudmunda/api/access_token.rb
+- lib/cloudmunda/api/client.rb
+- lib/cloudmunda/api/o_auth_resource.rb
+- lib/cloudmunda/cli.rb
+- lib/cloudmunda/cli/launcher.rb
+- lib/cloudmunda/cli/processor.rb
+- lib/cloudmunda/cli/supervisor.rb
+- lib/cloudmunda/cli/worker.rb
+- lib/cloudmunda/configuration.rb
+- lib/cloudmunda/graphql.rb
+- lib/cloudmunda/graphql/client.rb
+- lib/cloudmunda/graphql/user_tasks.rb
+- lib/cloudmunda/loggable.rb
 - lib/cloudmunda/version.rb
+- lib/cloudmunda/zeebe.rb
+- lib/cloudmunda/zeebe/client.rb
 homepage: https://github.com/lienvdsteen/cloudmunda
 licenses:
 - MIT