From 1d25b7f792f3acbdb93752ce46d77ce2e17dbd8a Mon Sep 17 00:00:00 2001 From: Pierre-Yves Date: Fri, 16 Aug 2024 14:47:36 -0700 Subject: [PATCH] Change the multithreading during createProcessInstance (#71) * Change the multithreading during createProcessInstance * Reformat --- README.md | 8 +- doc/scenarioreference/README.md | 124 ++++++++++++++---- pom.xml | 2 +- .../org/camunda/automator/AutomatorCLI.java | 3 +- .../configuration/BpmnEngineList.java | 6 +- .../ConfigurationServersEngine.java | 6 + .../configuration/ConfigurationStartup.java | 7 + .../automator/definition/ScenarioStep.java | 22 ++-- .../automator/engine/RunParameters.java | 20 +++ .../camunda/automator/engine/RunScenario.java | 5 +- .../flow/CreateProcessInstanceThread.java | 21 ++- .../flow/RunScenarioFlowServiceTask.java | 3 +- .../unit/RunScenarioUnitStartEvent.java | 2 +- .../automator/services/AutomatorStartup.java | 3 +- src/main/resources/application.yaml | 8 ++ src/main/resources/banner.txt | 2 +- 16 files changed, 192 insertions(+), 50 deletions(-) diff --git a/README.md b/README.md index 865a1cd..77cc3fa 100644 --- a/README.md +++ b/README.md @@ -344,7 +344,7 @@ mvn clean install ```` Now, create a docker image ```` -docker build -t pierre-yves-monnet/processautomator:1.5.2 . +docker build -t pierre-yves-monnet/processautomator:1.6.0 . ```` @@ -352,15 +352,15 @@ docker build -t pierre-yves-monnet/processautomator:1.5.2 . Push the image to the Camunda hub (you must be login first to the docker registry) ```` -docker tag pierre-yves-monnet/processautomator:1.5.2 ghcr.io/camunda-community-hub/process-execution-automator:1.5.2 -docker push ghcr.io/camunda-community-hub/process-execution-automator:1.5.2 +docker tag pierre-yves-monnet/processautomator:1.6.0 ghcr.io/camunda-community-hub/process-execution-automator:1.6.0 +docker push ghcr.io/camunda-community-hub/process-execution-automator:1.6.0 ```` Tag as the latest: ```` -docker tag pierre-yves-monnet/processautomator:1.5.2 ghcr.io/camunda-community-hub/process-execution-automator:latest +docker tag pierre-yves-monnet/processautomator:1.6.0 ghcr.io/camunda-community-hub/process-execution-automator:latest docker push ghcr.io/camunda-community-hub/process-execution-automator:latest ```` diff --git a/doc/scenarioreference/README.md b/doc/scenarioreference/README.md index 76752b2..550f751 100644 --- a/doc/scenarioreference/README.md +++ b/doc/scenarioreference/README.md @@ -134,21 +134,35 @@ The parent attribute is "executions" |------------------------|-----------------------------------------------------------------------------------------------------------|---------------------------------| | Name | Name of execution | "name": "This is the first run" | | policy | "STOPATFIRSTERROR" or "CONTINUE": In case of an error, what is the next move. Default is STOPATFIRSTERROR | "policy": "STOPATFIRSTERROR" | -| numberProcessInstances | Number of process instances to create. Each process instance follows steps. | "numberProcessInstances": 45 | -| Number of threads | Number of threads to execute in parallel. Default is 1. | "numberOfThreads": 5 | -| execution | If false, the execution does not start. If not present, the default value is TRUE. | "execution" : false | + Then, the execution contains a list of steps. + ## STARTEVENT step Start a new process instance. -| Parameter | Explanation | Example | -|-----------|-------------------------------|----------------------------------| -| name | name of the step, optional | "name": "Happy path start event" | -| type | Specify the type (STARTEVENT) | "type": "STARTEVENT" | -| taskId | Activity ID of start event | "activityId": "StartEvent_1" | +| Parameter | Explanation | Example | +|--------------------|-----------------------------------------------------------------|-------------------------------------------------------------------------------------| +| name | name of the step, optional | "name": "Happy path start event" | +| type | Specify the type (STARTEVENT) | "type": "STARTEVENT" | +| taskId | Activity ID of start event | "activityId": "StartEvent_1" | +| numberOfExecutions | Number of execution: number of process instance to create | "numberOfExecutions" : 300 | +| frequency | Frequence to create the . ISO format (PT10S) | "frequency": "PT30S" | +| nbThreads | Number of threads to execute the creation in parallel (1) | "nbThreads": 30 | +| variables | List of variables (JSON file) to update | "variables": {"amount": 450, "account": "myBankAccount", "colors": ["blue","red"]} | +| variablesOperation | List of variables, but the value is an operation | | + +(1) see multithreading section + +The startup wake up every time. Then, it created the process instances during the period. +if after the period it can't create all the process instance, then it stop, and a warning is sent. +For example, with a frequency of 30 S and a number of execution of 300, two scenario: +* it wake up, and create the 300 PI in 5 second. So, it waits 25 seconds, wake up again and create 300 new PI +* it wake up. In 30 seconds, it creates only 240 PI. So, it stop the creation, send an error. Because the period is finish and a new one start, it start create again a new batch of 300. + + Example @@ -194,19 +208,21 @@ certain position, you may want to simulate the worker. Then, the Process-Aautoma service task. The real worker shouldbe deactivated then. If the service task is not found, then the scenario will have an error. -| Parameter | Explanation | Example | -|--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------| -| name | name of the step, optional | "name": "get Score" | -| type | Specify the type (SERVICETASK) | "type": "SERVICETASK" | -| delay | Deplay to wait before looking for the task, in ISO 8601 | "delay" : "PT0.1S" waits 100 ms | -| waitingTime | Wait for maximum this time before returning an error. Process-Automator queries the engine every 500 ms until this delay. Default value is 5 minutes | "waitingTime" : "PT10S" | -| taskId | Activity ID to query | "activityId": "review" | -| topic | Topic to search the task (mandatory in C8) | "topic" : "get-score" | -| streamEnqbled | Specify if the worker use the streamEnabled function . Default is true. | "streamEnabled: true | -| variables | List of variables (JSON file) to update | "variables": {"amount": 450, "account": "myBankAccount", "colors": ["blue","red"]} | -| variablesOperation | List of variables, but the value is an operation | | -| modeExecution | Implementation: options are CLASSICAL, THREAD, THREADTOKEN. Default is CLASSICAL | "modeExecution" : "CLASSICAL" | -| numberOfExecutions | Number of execution, the task may be multi-instance. Default is 1 | "numberOfExecutions" : 3 | +| Parameter | Explanation | Example | +|--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------| +| name | name of the step, optional | "name": "get Score" | +| type | Specify the type (SERVICETASK) | "type": "SERVICETASK" | +| delay | Deplay to wait before looking for the task, in ISO 8601 | "delay" : "PT0.1S" waits 100 ms | +| waitingTime | Wait for maximum this time before returning an error. Process-Automator queries the engine every 500 ms until this delay. Default value is 5 minutes | "waitingTime" : "PT10S" | +| taskId | Activity ID to query | "activityId": "review" | +| topic | Topic to search the task (mandatory in C8) | "topic" : "get-score" | +| streamEnqbled | Specify if the worker use the streamEnabled function . Default is true. | "streamEnabled: true | +| variables | List of variables (JSON file) to update | "variables": {"amount": 450, "account": "myBankAccount", "colors": ["blue","red"]} | +| variablesOperation | List of variables, but the value is an operation | | +| modeExecution | Implementation: options are CLASSICAL, THREAD, THREADTOKEN. Default is CLASSICAL | "modeExecution" : "CLASSICAL" | +| nbTokens | Number of token (modeExecution==THREADTOKEN).Default is 1 | "nbTokens" : 200 | + +See the Multithreading section There is different implementation for the worker. Choose the one you will use for the simulation. @@ -231,7 +247,7 @@ just send 300 requests and wait for the return. To control the number of threads working on the worker and to get maximum efficiency, this implementation can be used. This is the same implementation as before, but a token acquisition is -added. To start the thread, the +added. The number of token is setup in value ## ENDEVENT step @@ -360,4 +376,68 @@ UserTaskThreshold(Activity_DiscoverySeedExtraction_TheEnd,7) ```` +# multi threading + +To send more request on server, it's possible to scale the different topic + +## Start event +During the start event operation, process instance are created. They are created per period. +Parameters are: + +| Parameter | Explanation | Example | +|--------------------|-----------------------------------------------------------------|-------------------------------------------------------------------------------------| +| numberOfExecutions | Number of execution: number of process instance to create | "numberOfExecutions" : 300 | +| frequency | Frequency to create the . ISO format (PT10S) | "frequency": "PT30S" | +| nbThreads | Number of threads to execute the creation in parallel (1) | "nbThreads": 30 | + +The frequency is the period to create the process instance. Let's use a frequency of 30 Seconds. Each 30 seconds, it will create numberOfExecutions process instances. +If it can't create this number, it will send a error. +To access this number, it's possible to multithreads the creation. This is the "nbWorkers" parameters. A threadPool is created with this value, and the numberOfExecutions creation is sent to this thread pool. + +The numberOfWorkers is part of the scenario. +It's possible to override this value via the application.yaml +```yaml +automator: + startevent: + nbThreads: 45 +``` +or by an environment variable in a kubernetes deployment +```yaml + +env: + - name: JAVA_TOOL_OPTIONS + value: >- + -Dautomator.startevent.nbThreads=200 +``` + +## Workers +A workers can be multi thread by two different mechanism: the asynchrounous execution and the multi threading execution + +**asynchronous execution** +it consist to not execute the treatment in the handle() or execute() method. This is done via a ThreadToken or an Asynchrounous mode. + +**Worker thread** +This section is only for Camunda 8. Camunda 7 have only one thread per worker. + +The number of threads for a worker is set at the Zeebe connection, not worker per worker. +These parameter are +```yaml + workerExecutionThreads: 100 + workerMaxJobsActive: 100 +``` + +It can be overridden by a environment variable in the Kubernetes file +```yaml + +env: + - name: JAVA_TOOL_OPTIONS + value: >- + -Dautomator.startup.serverName=zeebeCloud + -Dautomator.servers.camunda8.name=zeebeCloud + -Dautomator.servers.camunda8.workerExecutionThreads=100 +``` +By this method: +* you set up the server name (`automator.startup.serverName`) to use for the Zeebe Connection to `zeebeCloud` +* then, you qualify the camunda8 variable (`automator.servers.camunda8.name`) with this name. The Zeebe connection can be configured via the `automator.servers.camunda8`variables +* the number of threads are set to 100 via the `automator.servers.camunda8.workerExecutionThreads` variable. diff --git a/pom.xml b/pom.xml index b0c956c..472e140 100644 --- a/pom.xml +++ b/pom.xml @@ -6,7 +6,7 @@ org.camunda.community.automator process-execution-automator - 1.5.2 + 1.6.0 diff --git a/src/main/java/org/camunda/automator/AutomatorCLI.java b/src/main/java/org/camunda/automator/AutomatorCLI.java index 0ac51ba..479ac89 100644 --- a/src/main/java/org/camunda/automator/AutomatorCLI.java +++ b/src/main/java/org/camunda/automator/AutomatorCLI.java @@ -134,7 +134,8 @@ public void run(String[] args) { .setUserTask(configurationStartup.isPolicyExecutionUserTask()) .setWarmingUp(configurationStartup.isPolicyExecutionWarmingUp()) .setDeploymentProcess(configurationStartup.isPolicyDeployProcess()) - .setDeepTracking(configurationStartup.deepTracking()); + .setDeepTracking(configurationStartup.deepTracking()) + .setStartEventNbThreads(configurationStartup.getStartEventNbThreads()); List filterService = configurationStartup.getFilterService(); if (filterService != null) { runParameters.setFilterExecutionServiceTask(filterService); diff --git a/src/main/java/org/camunda/automator/configuration/BpmnEngineList.java b/src/main/java/org/camunda/automator/configuration/BpmnEngineList.java index 3d11dfc..2b8c49f 100644 --- a/src/main/java/org/camunda/automator/configuration/BpmnEngineList.java +++ b/src/main/java/org/camunda/automator/configuration/BpmnEngineList.java @@ -27,7 +27,7 @@ public class BpmnEngineList { public static final String CONF_WORKER_MAX_JOBS_ACTIVE = "workerMaxJobsActive"; public static final String CONF_WORKER_EXECUTION_THREADS = "workerExecutionThreads"; public static final String CONF_TASK_LIST_URL = "taskListUrl"; - public static final String CONF_TASK_LIST_USER = "taskListUserName"; + public static final String CONF_TASK_LIST_USER_NAME = "taskListUserName"; public static final String CONF_TASK_LIST_PASSWORD = "taskListUserPassword"; public static final String CONF_TASK_LIST_CLIENT_ID = "taskListClientId"; public static final String CONF_TASK_LIST_CLIENT_SECRET = "taskListClientSecret"; @@ -226,7 +226,7 @@ private List getFromServersList() throws AutomatorExceptio bpmnServerDefinition.operateAudience = getString(CONF_OPERATE_AUDIENCE, serverMap, null, contextLog, false); bpmnServerDefinition.taskListUrl = getString(CONF_TASK_LIST_URL, serverMap, null, contextLog, false); - bpmnServerDefinition.taskListUserName = getString(CONF_TASK_LIST_USER, serverMap, null, contextLog, false); + bpmnServerDefinition.taskListUserName = getString(CONF_TASK_LIST_USER_NAME, serverMap, null, contextLog, false); bpmnServerDefinition.taskListUserPassword = getString(CONF_TASK_LIST_PASSWORD, serverMap, null, contextLog, false); bpmnServerDefinition.taskListClientId = getString(CONF_TASK_LIST_CLIENT_ID, serverMap, null, contextLog, false); @@ -370,6 +370,8 @@ private List getFromServerConfiguration() { camunda8.operateUserName = configurationServersEngine.zeebeOperateUserName; camunda8.operateUserPassword = configurationServersEngine.zeebeOperateUserPassword; camunda8.taskListUrl = configurationServersEngine.zeebeTaskListUrl; + camunda8.taskListUserName = configurationServersEngine.zeebeTaskListUserName; + camunda8.taskListUserPassword = configurationServersEngine.zeebeTaskListUserPassword; list.add(camunda8); logger.info( "Configuration: Camunda8 Name[{}] zeebeGateway[{}] MaxJobsActive[{}] WorkerThreads[{}] " + "OperateURL[{}]", diff --git a/src/main/java/org/camunda/automator/configuration/ConfigurationServersEngine.java b/src/main/java/org/camunda/automator/configuration/ConfigurationServersEngine.java index 7422d61..c36017e 100644 --- a/src/main/java/org/camunda/automator/configuration/ConfigurationServersEngine.java +++ b/src/main/java/org/camunda/automator/configuration/ConfigurationServersEngine.java @@ -40,8 +40,14 @@ public class ConfigurationServersEngine { public String zeebeOperateUserName; @Value("${automator.servers.camunda8.operateUserPassword:''}") public String zeebeOperateUserPassword; + @Value("${automator.servers.camunda8.taskListUrl:''}") public String zeebeTaskListUrl; + @Value("${automator.servers.camunda8.taskListUserName:''}") + public String zeebeTaskListUserName; + @Value("${automator.servers.camunda8.taskListUserPassword:''}") + public String zeebeTaskListUserPassword; + @Value("${automator.servers.camunda8.workerExecutionThreads:''}") public String zeebeWorkerExecutionThreads; @Value("${automator.servers.camunda8.workerMaxJobsActive:''}") diff --git a/src/main/java/org/camunda/automator/configuration/ConfigurationStartup.java b/src/main/java/org/camunda/automator/configuration/ConfigurationStartup.java index 85d55c9..230f46a 100644 --- a/src/main/java/org/camunda/automator/configuration/ConfigurationStartup.java +++ b/src/main/java/org/camunda/automator/configuration/ConfigurationStartup.java @@ -27,6 +27,9 @@ public class ConfigurationStartup { @Value("${automator.startup.policyExecution:DEPLOYPROCESS|WARMINGUP|CREATION|SERVICETASK|USERTASK}") public String policyExecution; + @Value("${automator.startEvent.nbThreads:#{null}}") + public Integer startEventNbThreads; + /** * it may be necessary to wait the other component to warm up */ @@ -91,6 +94,10 @@ public boolean isPolicyDeployProcess() { return policyExtended.contains("|DEPLOYPROCESS|"); } + public Integer getStartEventNbThreads() { + return startEventNbThreads; + } + public List getScenarioFileAtStartup() { return recalibrateAfterSplit(scenarioFileAtStartup); } diff --git a/src/main/java/org/camunda/automator/definition/ScenarioStep.java b/src/main/java/org/camunda/automator/definition/ScenarioStep.java index 7f5a931..d451a6e 100644 --- a/src/main/java/org/camunda/automator/definition/ScenarioStep.java +++ b/src/main/java/org/camunda/automator/definition/ScenarioStep.java @@ -30,7 +30,9 @@ public class ScenarioStep { /** * In case of a Flow Step, the number of workers to execute this tasks */ - private Integer nbWorkers = Integer.valueOf(1); + private Integer nbThreads = Integer.valueOf(1); + + private final Integer nbTokens = null; /** * if the step is used in a WarmingUp operation, it can decide this is the time to finish it * Expression is @@ -206,12 +208,16 @@ public String getFrequency() { return frequency; } - public int getNbWorkers() { - return nbWorkers == null || nbWorkers == 0 ? 1 : nbWorkers; + public int getNbThreads() { + return nbThreads == null || nbThreads == 0 ? 1 : nbThreads; + } + + public void setNbThreads(int nbThreads) { + this.nbThreads = nbThreads; } - public void setNbWorkers(int nbWorkers) { - this.nbWorkers = nbWorkers; + public int getNbTokens() { + return nbTokens == null ? 1 : nbTokens; } public String getProcessId() { @@ -266,10 +272,10 @@ public String getId() { * CLASSICAL, WAIT: the worker wait the waitingTime time * THREAD, ASYNCHRONOUS: the worker release the method, wait asynchronously the waiting time and send back the answer * THREADTOKEN, ASYNCHRONOUSLIMITED: same as THREAD, but use the maxClient information to not accept more than this number - * In ASYNCHRONOUS, the method can potentially having millions of works in parallel (it accept works, - * but because it finish the method, then Zeebe Client will accept more works. So, with a waiting time of 1 mn, it may have a lot + * In ASYNCHRONOUS, the method can potentially have millions of works in parallel (it accept works, + * but because it finishes the method, then Zeebe Client will accept more works. So, with a waiting time of 1 mn, it may have a lot * of works in progress in the client. - * This mode limit the number of current execution on the worker. it redeem immediately the method, but when we reach this + * This mode limit the number of current execution on the worker. it redeems immediately the method, but when we reach this * limitation, it froze the worker, waiting for a slot. */ public enum MODEEXECUTION {CLASSICAL, THREAD, THREADTOKEN, WAIT, ASYNCHRONOUS, ASYNCHRONOUSLIMITED} diff --git a/src/main/java/org/camunda/automator/engine/RunParameters.java b/src/main/java/org/camunda/automator/engine/RunParameters.java index 4151bfe..4ce7b1b 100644 --- a/src/main/java/org/camunda/automator/engine/RunParameters.java +++ b/src/main/java/org/camunda/automator/engine/RunParameters.java @@ -10,6 +10,12 @@ public class RunParameters { private int numberOfThreadsPerScenario = 10; + /** + * Return the number of thread to use in the start event. Coming from the configuration. + * it may be n + */ + private Integer startEventNbThreads; + /** * Execute the scenario (execution part): create process instance, execute user & service task */ @@ -185,6 +191,20 @@ public RunParameters setNumberOfThreadsPerScenario(int numberOfThreadsPerScenari return this; } + /** + * return the nbThreads to use in a start event, comming from the configuration + * If the configuration does not specify anything, then return null. + * + * @return the number of thread to use for the start event + */ + public Integer getStartEventNbThreads() { + return startEventNbThreads; + } + + public void setStartEventNbThreads(Integer startEventNbThreads) { + this.startEventNbThreads = startEventNbThreads; + } + public boolean showLevelDebug() { return getLogLevelAsNumber() >= 5; } diff --git a/src/main/java/org/camunda/automator/engine/RunScenario.java b/src/main/java/org/camunda/automator/engine/RunScenario.java index 9892760..d7a88c6 100644 --- a/src/main/java/org/camunda/automator/engine/RunScenario.java +++ b/src/main/java/org/camunda/automator/engine/RunScenario.java @@ -139,11 +139,12 @@ public RunResult runDeployment() { public RunResult runExecutions() { RunResult result = new RunResult(this); result.setStartDate(new Date()); - // each execution is run in a different thread - ExecutorService executor = Executors.newFixedThreadPool(runParameters.getNumberOfThreadsPerScenario()); // the scenario can be an Execution or a Flow if (scenario.typeScenario.equals(Scenario.TYPESCENARIO.UNIT)) { + // each execution is run in a different thread + ExecutorService executor = Executors.newFixedThreadPool(runParameters.getNumberOfThreadsPerScenario()); + List> listFutures = new ArrayList<>(); logger.info("RunScenario: ------ execution UNIT scenario [{}] {} execution on {} Threads", scenario.getName(), scenario.getExecutions().size(), runParameters.getNumberOfThreadsPerScenario()); diff --git a/src/main/java/org/camunda/automator/engine/flow/CreateProcessInstanceThread.java b/src/main/java/org/camunda/automator/engine/flow/CreateProcessInstanceThread.java index d16a316..d71e754 100644 --- a/src/main/java/org/camunda/automator/engine/flow/CreateProcessInstanceThread.java +++ b/src/main/java/org/camunda/automator/engine/flow/CreateProcessInstanceThread.java @@ -48,14 +48,25 @@ public CreateProcessInstanceThread(int executionBatchNumber, */ public void createProcessInstances(Duration durationToCreateProcessInstances) { - int numberOfThreads = scenarioStep.getNbWorkers() == 0 ? 1 : scenarioStep.getNbWorkers(); + int nbThreads = scenarioStep.getNbThreads() == 0 ? 1 : scenarioStep.getNbThreads(); + + // the configuration may overload this value + Integer configurationNbThreads = runScenario.getRunParameters().getStartEventNbThreads(); + String additionalComment = ""; + if (configurationNbThreads != null) { + additionalComment = "(nbThreads overrided by the configuration: " + configurationNbThreads + ")"; + nbThreads = configurationNbThreads.intValue(); + } - ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads); + ExecutorService executor = Executors.newFixedThreadPool(nbThreads); int totalNumberOfPi = 0; - int processInstancePerThread = (int) Math.ceil(1.0 * scenarioStep.getNumberOfExecutions() / numberOfThreads); + int processInstancePerThread = (int) Math.ceil(1.0 * scenarioStep.getNumberOfExecutions() / nbThreads); + logger.info("StartNbThreads Step:[{}] PI:{} Duration:[{}] Thread:{} {} PI/thread:{}", scenarioStep.getTaskId(), + scenarioStep.getNumberOfExecutions(), durationToCreateProcessInstances, nbThreads, additionalComment, + processInstancePerThread); // Submit tasks to the executor - for (int i = 0; i < numberOfThreads; i++) { + for (int i = 0; i < nbThreads; i++) { int numberOfProcessInstanceToStart = Math.min(processInstancePerThread, scenarioStep.getNumberOfExecutions() - totalNumberOfPi); totalNumberOfPi += numberOfProcessInstanceToStart; @@ -122,7 +133,7 @@ private class StartProcess implements Runnable { Duration durationToCreateProcessInstances; /** - * @param executionBatchNumber + * @param executionBatchNumber batch number executed * @param indexInBatch the component number, when multiple component where generated to handle the flow * @param numberOfProcessInstanceToStart number of process instance to start by this object * @param durationToCreateProcessInstances duration max allowed to create process instance diff --git a/src/main/java/org/camunda/automator/engine/flow/RunScenarioFlowServiceTask.java b/src/main/java/org/camunda/automator/engine/flow/RunScenarioFlowServiceTask.java index af57571..c951b2c 100644 --- a/src/main/java/org/camunda/automator/engine/flow/RunScenarioFlowServiceTask.java +++ b/src/main/java/org/camunda/automator/engine/flow/RunScenarioFlowServiceTask.java @@ -49,8 +49,7 @@ public RunScenarioFlowServiceTask(TaskScheduler scheduler, RunResult runResult) { super(scenarioStep, runScenario, runResult); this.scheduler = scheduler; - this.semaphore = new Semaphore(runScenario.getBpmnEngine().getWorkerExecutionThreads()); - + this.semaphore = new Semaphore(Math.max(1, scenarioStep.getNbTokens())); } @Override diff --git a/src/main/java/org/camunda/automator/engine/unit/RunScenarioUnitStartEvent.java b/src/main/java/org/camunda/automator/engine/unit/RunScenarioUnitStartEvent.java index 710eca4..8353349 100644 --- a/src/main/java/org/camunda/automator/engine/unit/RunScenarioUnitStartEvent.java +++ b/src/main/java/org/camunda/automator/engine/unit/RunScenarioUnitStartEvent.java @@ -33,7 +33,7 @@ public RunResult startEvent(RunResult result, ScenarioStep step) { logger.info("StartEvent EventId[{}]", step.getTaskId()); } String processId = step.getScnExecution().getScnHead().getProcessId(); - // There is no multithread: index=1 + // There is no multithreading: index=1 Map processVariables = RunZeebeOperation.getVariablesStep(runScenario, step, 1); String processInstanceId = runScenario.getBpmnEngine() diff --git a/src/main/java/org/camunda/automator/services/AutomatorStartup.java b/src/main/java/org/camunda/automator/services/AutomatorStartup.java index b984c32..2610063 100644 --- a/src/main/java/org/camunda/automator/services/AutomatorStartup.java +++ b/src/main/java/org/camunda/automator/services/AutomatorStartup.java @@ -153,7 +153,8 @@ public void run() { .setUserTask(configurationStartup.isPolicyExecutionUserTask()) .setWarmingUp(configurationStartup.isPolicyExecutionWarmingUp()) .setDeploymentProcess(configurationStartup.isPolicyDeployProcess()) - .setDeepTracking(configurationStartup.deepTracking()); + .setDeepTracking(configurationStartup.deepTracking()) + .setStartEventNbThreads(configurationStartup.getStartEventNbThreads()); List filterService = configurationStartup.getFilterService(); if (filterService != null) { runParameters.setFilterExecutionServiceTask(filterService); diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml index 067578c..5d93760 100644 --- a/src/main/resources/application.yaml +++ b/src/main/resources/application.yaml @@ -24,6 +24,11 @@ automator: logDebug: false + # override the nbThread values in the scenario + # startEvent: + # nbThreads: 100 + + # servers connection is a list of connection separate by ; # each connection contains a name and a type. then, other parameters depends on the type # ,CAMUNDA_7, @@ -42,6 +47,7 @@ automator: workerMaxJobsActive: 20 - type: "camunda8" + description: "Simple authentication" name: "Camunda8Ruby" zeebeGatewayAddress: "127.0.0.1:26500" operateUserName: "demo" @@ -122,6 +128,8 @@ automator: operateUserPassword: "demo" operateUrl: "http://localhost:8081" taskListUrl: "http://localhost:8082" + taskListUserName: "demo" + taskListUserPassword: "demo" workerExecutionThreads: 200 workerMaxJobsActive: 200 diff --git a/src/main/resources/banner.txt b/src/main/resources/banner.txt index c4f684f..48c8a12 100644 --- a/src/main/resources/banner.txt +++ b/src/main/resources/banner.txt @@ -5,4 +5,4 @@ __________ __ |____| |__| \____/ \___ >___ >____ >____ > (____ /____/ |__| \____/|__|_| (____ /__| \____/|__| \/ \/ \/ \/ \/ \/ \/ - (v1.5.2) + (v1.6.0)