Merge pull request #36 from longquanzheng/worker

Add a sample for how to use more options in worker

Author: longquanzheng

src/main/java/com/uber/cadence/samples/hello/HelloWorkerSetup.java

@@ -0,0 +1,122 @@
+/*
+ *  Copyright 2012-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Modifications copyright (C) 2017 Uber Technologies, Inc.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"). You may not
+ *  use this file except in compliance with the License. A copy of the License is
+ *  located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ *  or in the "license" file accompanying this file. This file is distributed on
+ *  an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ *  express or implied. See the License for the specific language governing
+ *  permissions and limitations under the License.
+ */
+
+package com.uber.cadence.samples.hello;
+
+import com.uber.cadence.activity.ActivityMethod;
+import com.uber.cadence.client.WorkflowClient;
+import com.uber.cadence.worker.Worker;
+import com.uber.cadence.worker.WorkerOptions;
+import com.uber.cadence.workflow.Workflow;
+import com.uber.cadence.workflow.WorkflowMethod;
+
+import static com.uber.cadence.samples.common.SampleConstants.DOMAIN;
+
+/**
+ * Hello World Cadence workflow that executes a single activity with full example of how to customize
+ * a worker
+ */
+public class HelloWorkerSetup {
+
+  static final String TASK_LIST = "HelloActivity";
+
+  /** Workflow interface has to have at least one method annotated with @WorkflowMethod. */
+  public interface GreetingWorkflow {
+    /** @return greeting string */
+    @WorkflowMethod(executionStartToCloseTimeoutSeconds = 10, taskList = TASK_LIST)
+    String getGreeting(String name);
+  }
+
+  /** Activity interface is just a POJI. */
+  public interface GreetingActivities {
+    @ActivityMethod(scheduleToCloseTimeoutSeconds = 2)
+    String composeGreeting(String greeting, String name);
+  }
+
+  /** GreetingWorkflow implementation that calls GreetingsActivities#composeGreeting. */
+  public static class GreetingWorkflowImpl implements GreetingWorkflow {
+
+    /**
+     * Activity stub implements activity interface and proxies calls to it to Cadence activity
+     * invocations. Because activities are reentrant, only a single stub can be used for multiple
+     * activity invocations.
+     */
+    private final GreetingActivities activities =
+        Workflow.newActivityStub(GreetingActivities.class);
+
+    @Override
+    public String getGreeting(String name) {
+      // This is a blocking call that returns only after the activity has completed.
+      return activities.composeGreeting("Hello", name);
+    }
+  }
+
+  static class GreetingActivitiesImpl implements GreetingActivities {
+    @Override
+    public String composeGreeting(String greeting, String name) {
+      return greeting + " " + name + "!";
+    }
+  }
+
+  public static void main(String[] args) {
+    // Start a worker that hosts both workflow and activity implementations.
+
+    /**
+     * If you see error "Not enough threads to execute workflows" exception it indicates that there are
+     * not enough threads to execute currently running workflow tasks.
+     *
+     * For example, if each workflow uses two threads(using Asycn function) and maxConcurrentWorklfowExecutionSize is 100,
+     * and assuming the factory only creates one worker. Then maxWorkflowThreads should be at least 200.
+     * With such setup 0 workflows will be cached as all the threads would be consumed by the currently executing workflow tasks.
+     * So in general it is better to keep maxWorkflowThreads much higher than maxConcurrentWorklfowExecutionSize to support caching.
+     *
+     * maxWorkflowThreads defines how many threads all currently executing and cached workflows can use.
+     * It's a Factory level option, meaning that the thread pool is shared across all workers created by the factory.
+     *
+     * maxConcurrentWorklfowExecutionSize defines how many workflow tasks can execute in parallel.
+     * It's a worker level option.
+     *
+     *
+     */
+    Worker.Factory factory = new Worker.Factory(DOMAIN,
+            new Worker.FactoryOptions.Builder()
+                    .setMaxWorkflowThreadCount(1000)
+                    .setCacheMaximumSize(100)
+                    .setDisableStickyExecution(false)
+                    .build());
+    Worker worker = factory.newWorker(TASK_LIST,
+            new WorkerOptions.Builder()
+                    .setMaxConcurrentActivityExecutionSize(100)
+                    .setMaxConcurrentWorkflowExecutionSize(100)
+                    .build());
+    // Workflows are stateful. So you need a type to create instances.
+    worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class);
+    // Activities are stateless and thread safe. So a shared instance is used.
+    worker.registerActivitiesImplementations(new GreetingActivitiesImpl());
+    // Start listening to the workflow and activity task lists.
+    factory.start();
+
+    // Start a workflow execution. Usually this is done from another program.
+    WorkflowClient workflowClient = WorkflowClient.newInstance(DOMAIN);
+    // Get a workflow stub using the same task list the worker uses.
+    GreetingWorkflow workflow = workflowClient.newWorkflowStub(GreetingWorkflow.class);
+    // Execute a workflow waiting for it to complete.
+    String greeting = workflow.getGreeting("World");
+    System.out.println(greeting);
+    System.exit(0);
+  }
+}