camunda-workflow 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de3f5b53f63bf54079ee7c40c5b4484610f5fff5aea834f277c53c2a19061066
-  data.tar.gz: 9bc948e1114eb799505598a585874070436097ec1ee86396f806457aad8a304c
+  metadata.gz: 3968856a19853532f780e7e81b3449a7e9d45bc23f699a22ddc25e400d787318
+  data.tar.gz: fa0c4ed150e0fabb72c11bbbff14c1f32b7da908b642511de3fe0e674423ba23
 SHA512:
-  metadata.gz: 75e7a0452733b6c14c62a60bcb794c29d5760431721ab85bc138ea3bb35e32ae11803466247de18ec86825f4f057963f9735744c6418b5549f2f0811dd9f13d2
-  data.tar.gz: f97120868b79674a2dc60c04d7c646fe511da2674113f198da67fcfc6081507fc263edc8713d4631e371c979cea2f9b564f62a846c316856170b8640089e5063
+  metadata.gz: e009f167b8de5e94972ae2e98b1dc97ebdd8c927d6034c5b7461b2c3c41c56ab28590fd8546d8d2049c81892fa9cd0a3de37c933cfc9539a8434a5eebd1c0357
+  data.tar.gz: 57651fbbc6eafc00625a5ac5d826f2b5192979b961f6164cc46d0b44e2fca15492b0be1889f7aacd0a56f112b997c1040d1aa7b69416895ed16a69078e9c7406

data/CHANGELOG.md

@@ -1,13 +1,33 @@
 # Changelog
 
-## [Unreleased](https://github.com/amalagaura/camunda-workflow/tree/HEAD)
+## [v0.2.2](https://github.com/amalagaura/camunda-workflow/tree/v0.2.2) (2020-01-08)
 
-[Full Changelog](https://github.com/amalagaura/camunda-workflow/compare/v0.2.0...HEAD)
+[Full Changelog](https://github.com/amalagaura/camunda-workflow/compare/v0.2.1...v0.2.2)
 
 **Closed issues:**
 
+- The task for Message End Events is on the parent node of camunda:type="external" [\#34](https://github.com/amalagaura/camunda-workflow/issues/34)
+- Error in documentation regarding deployment of BPMN files.  [\#32](https://github.com/amalagaura/camunda-workflow/issues/32)
+
+**Merged pull requests:**
+
+- Camunda calls the external task from bpmn:endEvent [\#35](https://github.com/amalagaura/camunda-workflow/pull/35) ([amalagaura](https://github.com/amalagaura))
+- fixed documentation on README [\#33](https://github.com/amalagaura/camunda-workflow/pull/33) ([curatingbits](https://github.com/curatingbits))
+
+## [v0.2.1](https://github.com/amalagaura/camunda-workflow/tree/v0.2.1) (2019-12-28)
+
+[Full Changelog](https://github.com/amalagaura/camunda-workflow/compare/v0.2.0...v0.2.1)
+
+**Closed issues:**
+
+- Include gems via Railtie instead of by copying the .rake file [\#29](https://github.com/amalagaura/camunda-workflow/issues/29)
 - Remove check for what bpmn\_perform returns. Ignore if not a hash. [\#27](https://github.com/amalagaura/camunda-workflow/issues/27)
 
+**Merged pull requests:**
+
+- Remove startup error instructions [\#31](https://github.com/amalagaura/camunda-workflow/pull/31) ([amalagaura](https://github.com/amalagaura))
+- create railtie to include rake tasks [\#30](https://github.com/amalagaura/camunda-workflow/pull/30) ([curatingbits](https://github.com/curatingbits))
+
 ## [v0.2.0](https://github.com/amalagaura/camunda-workflow/tree/v0.2.0) (2019-12-20)
 
 [Full Changelog](https://github.com/amalagaura/camunda-workflow/compare/v0.1.5...v0.2.0)

data/README.md

@@ -153,7 +153,7 @@ It will fail to start. Create a postgres database as a service in PCF and bind i
 
 ## Usage
 
- ### Add to your Gemfile
+### Add to your Gemfile
 ```ruby
   gem 'camunda-workflow'
 ```
@@ -162,7 +162,7 @@ It will fail to start. Create a postgres database as a service in PCF and bind i
 Uses a default name, etc. Below outlines how to deploy a process using the included sample.bpmn file created by the generator. Alternatively you can deploy using Camunda Modeler
 
 ```ruby
- Camunda::Deployment.create file_name: 'bpmn/diagrams/sample.bpmn'
+ Camunda::Deployment.create file_names: ['bpmn/diagrams/sample.bpmn']
 ```
 ### Processes
 
@@ -198,6 +198,16 @@ Poller will need to run in a separate process or thread and needs to be running
  Camunda::Poller.fetch_and_queue %w[CamundaWorkflow]
  ```
 
+#### Running the poller in a separate thread
+We have had success with running a long running thread in a Rails app using [Rufus Scheduler](https://github.com/jmettraux/rufus-scheduler). Something like:
+
+```
+rufus_scheduler.in('10.seconds') do
+  Camunda::Poller.fetch_and_queue %w[Topics]
+end
+```
+
+
 #### Fetch tasks For testing from the console
 
 ```ruby

data/lib/camunda/bpmn_xml.rb

@@ -20,9 +20,14 @@ class Camunda::BpmnXML
 
   # creates a new instance of Camunda::BpmnXML::Task
   def external_tasks
-    @doc.xpath('//*[@camunda:type="external"]').map do |task|
+    @doc.xpath('(//bpmn:serviceTask[@camunda:type="external"]|//bpmn:sendTask[@camunda:type="external"])').map do |task|
       Task.new(task)
-    end
+    end +
+      @doc.xpath('//bpmn:endEvent/bpmn:messageEventDefinition[@camunda:type="external"]').map do |child_node|
+        task = child_node.parent.dup
+        task["topic"] = child_node["topic"]
+        Task.new(task)
+      end
   end
 
   # We may have tasks with different topics. Returns classes with topics which are the same as the BPMN process id

data/lib/camunda/external_task.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/string/inflections.rb'
+require 'active_support/core_ext/string/inflections'
 require 'active_support/backtrace_cleaner'
 # External Tasks are the task entity for camunda. We can query the topic and lock the task. After the task
 # is locked, the external task of the process instance can be worked and completed. Below is an excerpt from the Camunda
@@ -133,6 +133,25 @@ class Camunda::ExternalTask < Camunda::Model
                  topics: topic_details
   end
 
+  # Locking means that the task is reserved for this worker for a certain duration beginning with the time of fetching and
+  # prevents that another worker can fetch the same task while the lock is valid. Locking duration is set in the the
+  # Camunda::Workflow configuration. Before an external task can be completed, it must be locked.
+  #
+  # This method calls fetch_and_lock and then queues the jobs that were retrieved
+  # @example
+  #   task = Camunda::ExternalTask.fetch_and_queue("CamundaWorkflow")
+  # @param topics [Array<String>] definition keys
+  # @param lock_duration [Integer]
+  # @param long_polling_duration [Integer]
+  # @return [Camunda::ExternalTask]
+  def self.fetch_and_queue(topics, lock_duration: nil, long_polling_duration: nil)
+    fetch_and_lock(topics, lock_duration: lock_duration, long_polling_duration: long_polling_duration).each do |task|
+      task.queue_task
+    rescue Camunda::MissingImplementationClass => e
+      task.failure(e)
+    end
+  end
+
   # Returns the class name which is supposed to implement this task
   # @return [String] modularized class name of bpmn task implementation
   def task_class_name

data/lib/camunda/model.rb

@@ -3,6 +3,10 @@ require 'her/model'
 class Camunda::Model
   include Her::Model
 
+  def self.log_details?
+    defined?(Rails) && Rails.env.development?
+  end
+
   # We use a lambda so that this is evaluated after Camunda::Workflow.configuration is set
   api = lambda do
     # Configuration for Her and Faraday requests and responses
@@ -14,12 +18,15 @@ class Camunda::Model
       c.use Faraday::Request::BasicAuthentication, Camunda::Workflow.configuration.camunda_user,
             Camunda::Workflow.configuration.camunda_password
       # Response
-      c.use Faraday::Response::Logger, ActiveSupport::Logger.new(STDOUT), bodies: true if Rails.env.development?
+      c.use Faraday::Response::Logger, ActiveSupport::Logger.new($stdout), bodies: true if log_details?
       c.use Her::Middleware::FirstLevelParseJSON
 
       c.use Her::Middleware::SnakeCase
       # Adapter
       c.adapter :net_http
+
+      # HTTP proxy
+      c.proxy = Camunda::Workflow.configuration.http_proxy if Camunda::Workflow.configuration.http_proxy
     end
   end
 

data/lib/camunda/poller.rb

@@ -15,12 +15,7 @@ class Camunda::Poller
   # @param long_polling_duration [Integer] long polling time, default is set to Camunda::Workflow.configuration
   def self.fetch_and_queue(topics, lock_duration: nil, long_polling_duration: nil)
     loop do
-      Camunda::ExternalTask
-        .fetch_and_lock(topics, lock_duration: lock_duration, long_polling_duration: long_polling_duration).each do |task|
-        task.queue_task
-      rescue Camunda::MissingImplementationClass => e
-        task.failure(e)
-      end
+      Camunda::ExternalTask.fetch_and_queue(topics, lock_duration: lock_duration, long_polling_duration: long_polling_duration)
     end
   end
 end

data/lib/camunda/process_definition.rb

@@ -23,9 +23,7 @@ class Camunda::ProcessDefinition < Camunda::Model
     tenant_id ||= Camunda::Workflow.configuration.tenant_id
 
     response = post_raw start_path_for_key(key, tenant_id), hash
-    raise Camunda::ProcessEngineException, response[:parsed_data][:data][:message] unless response[:response].status == 200
-
-    Camunda::ProcessInstance.new response[:parsed_data][:data]
+    process_instance_result(response)
   end
 
   # Starts an individual process instance for a process definition. The below example shows how to start a process
@@ -40,9 +38,7 @@ class Camunda::ProcessDefinition < Camunda::Model
   def start(hash={})
     hash[:variables] = serialize_variables(hash[:variables]) if hash[:variables]
     response = self.class.post_raw "process-definition/#{id}/start", hash
-    raise Camunda::ProcessEngineException, response[:parsed_data][:data][:message] unless response[:response].status == 200
-
-    Camunda::ProcessInstance.new response[:parsed_data][:data]
+    self.class.process_instance_result(response)
   end
 
   # Sets path to include tenant_id if a tenant_id is provided with a process definition on deployment.
@@ -51,4 +47,13 @@ class Camunda::ProcessDefinition < Camunda::Model
     path << "/tenant-id/#{tenant_id}" if tenant_id
     "#{path}/start"
   end
+
+  def self.process_instance_result(response)
+    unless response[:response].status == 200
+      raise Camunda::ProcessEngineException,
+            "#{response[:parsed_data][:data][:message]} HTTP Status: #{response[:response].status}"
+    end
+
+    Camunda::ProcessInstance.new response[:parsed_data][:data]
+  end
 end

data/lib/camunda/task.rb

@@ -35,6 +35,24 @@ class Camunda::Task < Camunda::Model
     end
   end
 
+  def bpmn_error!(error_code, error_message, vars={})
+    self.class
+        .post_raw("#{self.class.collection_path}/#{id}/bpmnError", errorCode: error_code, errorMessage: error_message,
+                                                                   variables: serialize_variables(vars))[:response]
+        .tap do |response|
+      raise SubmissionError, response.body[:data][:message] unless response.success?
+    end
+  end
+
+  def bpmn_escalation!(escalation_code, vars={})
+    self.class
+        .post_raw("#{self.class.collection_path}/#{id}/bpmnEscalation", escalationCode: escalation_code,
+                                                                        variables: serialize_variables(vars))[:response]
+        .tap do |response|
+      raise SubmissionError, response.body[:data][:message] unless response.success?
+    end
+  end
+
   # Error class when the task cannot be submitted. For instance if the bpmn process expects a variable and the variable
   # isn't supplied, Camunda will not accept the task
   class SubmissionError < StandardError

data/lib/camunda/variable_serialization.rb

@@ -30,7 +30,7 @@ module Camunda
           when Float
             { value: value, type: 'Double' }
           else
-            raise ArgumentError, "Not supporting complex types yet"
+            raise ArgumentError, "#{value} - Not supporting complex types yet. Variables are #{variables}."
           end
         end
         camelcase_keys(hash)
@@ -41,9 +41,10 @@ module Camunda
       # @param json [Array,Hash]
       # @return [Hash] returns hash with camelCase keys
       def transform_json(json)
-        if json.is_a?(Array)
+        case json
+        when Array
           json.map { |element| transform_json(element) }
-        elsif json.is_a?(Hash)
+        when Hash
           camelcase_keys(json)
         else
           json

data/lib/camunda/workflow/version.rb

@@ -1,5 +1,5 @@
 module Camunda
   module Workflow
-    VERSION = '0.2.1'.freeze
+    VERSION = '0.3.1'.freeze
   end
 end

data/lib/camunda/workflow.rb

@@ -11,7 +11,7 @@ module Camunda
     # Implements Configuration class and sets default instance variables. The default variables can be overridden by creating an
     # initializer file within your rails application and setting the variables like in the example below.
     # @note if HTTP Basic Auth is used with the Camunda engine, this is where you would set a camunda_user and camunda_password
-    # using the creditials from a user setup in Camunda Admin.
+    # using the credentials from a user setup in Camunda Admin.
     # @example
     #   'Camunda::Workflow.configure do |config|
     #     config.engine_url = 'http://localhost:8080'
@@ -64,6 +64,9 @@ module Camunda
       # Can configure the backtrace silencer
       # @return [Array<String>] List of backtrace silencer strings which are used to clean incident backtraces
       attr_accessor :backtrace_silencer_lines
+      # Configure an HTTP proxy for all requests to use
+      # @return [String] The defined HTTP proxy
+      attr_accessor :http_proxy
 
       def initialize
         @engine_url = 'http://localhost:8080'

data/lib/camunda.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/string/inflections.rb'
-require 'active_support/core_ext/object/blank.rb'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/blank'
 require 'her'
 require 'faraday'
 require 'faraday_middleware'
@@ -10,6 +10,7 @@ module Camunda
   class << self
     # Allows setting the logger to a custom logger
     attr_writer :logger
+
     # Default is output to the standard output stream.
     # @return [Object] instance which is used for logging
     def logger
@@ -27,9 +28,10 @@ module Camunda
       return if env[:body].blank?
 
       json = JSON.parse(env[:body])
-      if json.is_a?(Array)
+      case json
+      when Array
         json.map { |hash| transform_hash!(hash) }
-      elsif json.is_a?(Hash)
+      when Hash
         transform_hash!(json)
       end
       env[:body] = JSON.generate(json)

data/lib/generators/camunda/spring_boot/spring_boot_generator.rb

@@ -35,9 +35,7 @@ module Camunda
         ignores << '.cfignore' if File.exist?('.cfignore')
         ignores.each do |file|
           append_to_file file do
-            "\n# BPMN Java app\n" +
-              File.join(java_app_path, 'target') +
-              "\n"
+            "\n# BPMN Java app\n#{File.join(java_app_path, 'target')}\n"
           end
         end
       end

data/lib/generators/camunda/spring_boot/templates/pom.xml

@@ -82,7 +82,7 @@
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
-      <version>42.2.7</version>
+      <version>42.2.25</version>
     </dependency>
 
     <dependency>

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: camunda-workflow
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Ankur Sethi
 - Duggan Roberts
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2019-11-22 00:00:00.000000000 Z
@@ -242,7 +242,7 @@ homepage: https://github.com/amalagaura/camunda-workflow
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -258,7 +258,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Opinionated Ruby integration with Camunda
 test_files: []