replication test

package io.temporal.samples.hello;

import io.temporal.activity.ActivityInterface; import io.temporal.activity.ActivityMethod; import io.temporal.activity.ActivityOptions; import io.temporal.client.WorkflowClient; import io.temporal.client.WorkflowClientOptions; import io.temporal.client.WorkflowOptions; import io.temporal.serviceclient.WorkflowServiceStubs; import io.temporal.worker.Worker; import io.temporal.worker.WorkerFactory; import io.temporal.workflow.SignalMethod; import io.temporal.workflow.Workflow; import io.temporal.workflow.WorkflowInterface; import io.temporal.workflow.WorkflowMethod; import java.time.Duration; import org.slf4j.Logger; import org.slf4j.LoggerFactory;

/** Sample Temporal Workflow Definition that executes a single Activity. */ public class HelloActivity {

// Define the task queue name static final String TASK_QUEUE = "HelloActivityTaskQueue";

// Define our workflow unique id static final String WORKFLOW_ID = "HelloActivityWorkflow";

/**

• The Workflow Definition's Interface must contain one method annotated with @WorkflowMethod.

• Workflow Definitions should not contain any heavyweight computations, non-deterministic

• code, network calls, database operations, etc. Those things should be handled by the
• Activities.
• @see io.temporal.workflow.WorkflowInterface
• @see io.temporal.workflow.WorkflowMethod */ @WorkflowInterface public interface GreetingWorkflow {

/**

 * This is the method that is executed when the Workflow Execution is started. The Workflow
 * Execution completes when this method finishes execution.
 */
@WorkflowMethod
String getGreeting(String name);

@SignalMethod
void doContinue();

}

/**

• This is the Activity Definition's Interface. Activities are building blocks of any Temporal
• Workflow and contain any business logic that could perform long running computation, network
• calls, etc.

• Annotating Activity Definition methods with @ActivityMethod is optional.

• @see io.temporal.activity.ActivityInterface
• @see io.temporal.activity.ActivityMethod */ @ActivityInterface public interface GreetingActivities {

// Define your activity method which can be called during workflow execution

@ActivityMethod(name = "greet")
String composeGreeting(String greeting, String name);

}

// Define the workflow implementation which implements our getGreeting workflow method. public static class GreetingWorkflowImpl implements GreetingWorkflow {

/**
 * Define the GreetingActivities stub. Activity stubs are proxies for activity invocations that
 * are executed outside of the workflow thread on the activity worker, that can be on a
 * different host. Temporal is going to dispatch the activity results back to the workflow and
 * unblock the stub as soon as activity is completed on the activity worker.
 *
 * <p>In the {@link ActivityOptions} definition the "setStartToCloseTimeout" option sets the
 * overall timeout that our workflow is willing to wait for activity to complete. For this
 * example it is set to 2 seconds.
 */
private boolean cont = false;

private final GreetingActivities activities =
    Workflow.newActivityStub(
        GreetingActivities.class,
        ActivityOptions.newBuilder().setStartToCloseTimeout(Duration.ofSeconds(2)).build());

@Override
public String getGreeting(String name) {
  // This is a blocking call that returns only after the activity has completed.
  String res = activities.composeGreeting("Hello", name);

  Workflow.await(() -> cont);

  return res;
}

@Override
public void doContinue() {
  this.cont = true;
}

}

/** Simple activity implementation, that concatenates two strings. */ public static class GreetingActivitiesImpl implements GreetingActivities { private static final Logger log = LoggerFactory.getLogger(GreetingActivitiesImpl.class);

@Override
public String composeGreeting(String greeting, String name) {
  log.info("Composing greeting...");
  return greeting + " " + name + "!";
}

}

/**

• With our Workflow and Activities defined, we can now start execution. The main method starts
• the worker and then the workflow. */ public static void main(String[] args) {

// Get a Workflow service stub.

WorkflowServiceStubs service = WorkflowServiceStubs.newLocalServiceStubs();

/*
 * Get a Workflow service client which can be used to start, Signal, and Query Workflow Executions.
 */
WorkflowClient client =
    WorkflowClient.newInstance(
        service,
        WorkflowClientOptions.newBuilder()
            .setNamespace("replicationtest")
            .validateAndBuildWithDefaults());

/*
 * Define the workflow factory. It is used to create workflow workers for a specific task queue.
 */
WorkerFactory factory = WorkerFactory.newInstance(client);

/*
 * Define the workflow worker. Workflow workers listen to a defined task queue and process
 * workflows and activities.
 */
Worker worker = factory.newWorker(TASK_QUEUE);

/*
 * Register our workflow implementation with the worker.
 * Workflow implementations must be known to the worker at runtime in
 * order to dispatch workflow tasks.
 */
worker.registerWorkflowImplementationTypes(GreetingWorkflowImpl.class);

/*
 * Register our Activity Types with the Worker. Since Activities are stateless and thread-safe,
 * the Activity Type is a shared instance.
 */
worker.registerActivitiesImplementations(new GreetingActivitiesImpl());

/*
 * Start all the workers registered for a specific task queue.
 * The started workers then start polling for workflows and activities.
 */
factory.start();

// Create the workflow client stub. It is used to start our workflow execution.
for (int i = 0; i < 30; i++) {
  GreetingWorkflow workflow =
      client.newWorkflowStub(
          GreetingWorkflow.class,
          WorkflowOptions.newBuilder()
              .setWorkflowId(WORKFLOW_ID + i)
              .setTaskQueue(TASK_QUEUE)
              .build());

  /*
   * Execute our workflow and wait for it to complete. The call to our getGreeting method is
   * synchronous.
   *
   * See {@link io.temporal.samples.hello.HelloSignal} for an example of starting workflow
   * without waiting synchronously for its result.
   */
  WorkflowClient.start(workflow::getGreeting, "Hello World");
}

sleep(3);

// only send signals to 20 of these execs, leave 10 open w/o signal
for (int j = 0; j < 20; j++) {
  GreetingWorkflow workflow = client.newWorkflowStub(GreetingWorkflow.class, WORKFLOW_ID + j);
  workflow.doContinue();
}

// Display workflow execution results
//    System.out.println(greeting);
//    System.exit(0);

}

private static void sleep(int seconds) { try { Thread.sleep(seconds * 1000L); } catch (Exception e) { System.out.println("*E: " + e.getMessage()); } } }