public WorkflowTestBase(DecisionContext decisionContext) {
   this.decisionContext = decisionContext;
   workflowContext = (TestWorkflowContext) decisionContext.getWorkflowContext();
   workflowClock = (TestWorkflowClock) decisionContext.getWorkflowClock();
   WorkflowExecution we = new WorkflowExecution();
   we.setWorkflowId("testWorkflowId");
   we.setRunId("testRunId");
   workflowContext.setWorkflowExecution(we);
   WorkflowType wt = new WorkflowType();
   wt.setName("testWorkflow");
   wt.setVersion("0.0");
   workflowContext.setWorkflowType(wt);
 }
 @Override
 protected void doFinally() throws Throwable {
   if (!failed) {
     continueAsNew.set(childContext.getWorkflowContext().getContinueAsNewOnCompletion());
     if (continueAsNew.get() == null && executeResult.isReady()) {
       result.set(executeResult.get());
     }
   } else {
     continueAsNew.set(null);
   }
   workflowExecutions.remove(this.childExecution.getWorkflowId());
 }
 public void continueAsNewOnCompletion(ContinueAsNewWorkflowExecutionParameters parameters) {
   DecisionContext decisionContext = decisionContextProvider.getDecisionContext();
   decisionContext.getWorkflowContext().setContinueAsNewOnCompletion(parameters);
 }
  private void startChildWorkflow(
      final StartChildWorkflowExecutionParameters parameters,
      final Settable<StartChildWorkflowReply> reply,
      final Settable<String> result) {
    String workflowId = parameters.getWorkflowId();
    WorkflowType workflowType = parameters.getWorkflowType();
    WorkflowExecution childExecution = new WorkflowExecution();
    final String runId = UUID.randomUUID().toString();
    // TODO: Validate parameters against registration options to find missing timeouts or other
    // options
    try {
      DecisionContext parentDecisionContext = decisionContextProvider.getDecisionContext();
      if (workflowId == null) {
        workflowId =
            decisionContextProvider.getDecisionContext().getWorkflowClient().generateUniqueId();
      }
      childExecution.setWorkflowId(workflowId);
      childExecution.setRunId(runId);

      final GenericActivityClient activityClient = parentDecisionContext.getActivityClient();
      final WorkflowClock workflowClock = parentDecisionContext.getWorkflowClock();
      WorkflowDefinitionFactory factory;
      if (factoryFactory == null) {
        throw new IllegalStateException("required property factoryFactory is null");
      }
      factory = factoryFactory.getWorkflowDefinitionFactory(workflowType);
      if (factory == null) {
        String cause =
            StartChildWorkflowExecutionFailedCause.WORKFLOW_TYPE_DOES_NOT_EXIST.toString();
        throw new StartChildWorkflowFailedException(0, childExecution, workflowType, cause);
      }
      TestWorkflowContext workflowContext = new TestWorkflowContext();
      workflowContext.setWorkflowExecution(childExecution);
      workflowContext.setWorkflowType(parameters.getWorkflowType());
      workflowContext.setParentWorkflowExecution(
          parentDecisionContext.getWorkflowContext().getWorkflowExecution());
      workflowContext.setTagList(parameters.getTagList());
      workflowContext.setTaskList(parameters.getTaskList());
      DecisionContext context =
          new TestDecisionContext(
              activityClient, TestGenericWorkflowClient.this, workflowClock, workflowContext);
      // this, parameters, childExecution, workflowClock, activityClient);
      final WorkflowDefinition childWorkflowDefinition = factory.getWorkflowDefinition(context);
      final ChildWorkflowTryCatchFinally tryCatch =
          new ChildWorkflowTryCatchFinally(
              parameters, childExecution, childWorkflowDefinition, context, result);
      workflowContext.setRootTryCatch(tryCatch);
      ChildWorkflowTryCatchFinally currentRun = workflowExecutions.get(workflowId);
      if (currentRun != null) {
        String cause = StartChildWorkflowExecutionFailedCause.WORKFLOW_ALREADY_RUNNING.toString();
        throw new StartChildWorkflowFailedException(0, childExecution, workflowType, cause);
      }
      workflowExecutions.put(workflowId, tryCatch);
      continueAsNewWorkflowExecution(tryCatch, result);
    } catch (StartChildWorkflowFailedException e) {
      throw e;
    } catch (Throwable e) {
      // This cause is chosen to represent internal error for sub-workflow creation
      String cause = StartChildWorkflowExecutionFailedCause.OPEN_CHILDREN_LIMIT_EXCEEDED.toString();
      StartChildWorkflowFailedException failure =
          new StartChildWorkflowFailedException(0, childExecution, workflowType, cause);
      failure.initCause(e);
      throw failure;
    } finally {
      reply.set(new StartChildWorkflowReplyImpl(result, runId));
    }
  }
예제 #5
0
public class NonTxWorkflowImpl implements NonTxWorkflow {
  DecisionContextProvider contextProvider = new DecisionContextProviderImpl();
  DecisionContextProvider provider = new DecisionContextProviderImpl();
  DecisionContext context = provider.getDecisionContext();
  private WorkflowClock clock = context.getWorkflowClock();
  private final int confirmationPeriod = 3500;
  BitcoindActivitiesClient bcdClient = new BitcoindActivitiesClientImpl();
  MessagingActivitiesClient msgClient = new MessagingActivitiesClientImpl();

  @Override
  public void executeCommand(final DataSet data) {
    new TryCatch() {
      @Override
      protected void doTry() throws Throwable {
        if (data.getAction() == Action.DEPOSIT_REQ) {
          Promise<String> bcAddress = bcdClient.getNewAddress(data.getCn());
          respondDepositReq(bcAddress, data);
        } else if (data.getAction() == Action.SIGNUP) {
          Promise<Void> done = msgClient.sendMessage(data);
          createAddress(done, data);
        } else if (data.getAction() == Action.GW_DEPOSIT_REQ) {
          Promise<String> bcAddress = bcdClient.getNewAddress(data.getCn());
          respondDataReq(bcAddress, data);
        } else if (data.getAction() == Action.BALANCE) {
          Promise<BigDecimal> balance = bcdClient.getAccountBalance(data.getCn());
          Promise<BigDecimal> fee = msgClient.readAccountFee(data.getCn());
          respondBalance(balance, fee, data);
        } else if (data.getAction() == Action.GW_BALANCE) {
          Promise<BigDecimal> balance = bcdClient.getAccountBalance(data.getCn());
          cacheBalance(balance, data);
        } else if (data.getAction() == Action.TRANSACTION) {
          Promise<List<Transaction>> transactions = bcdClient.getAccountTransactions(data.getCn());
          respondTransactions(transactions, data);
        } else if (data.getAction() == Action.VOICE) {
          final Settable<DataSet> confirm = new Settable<>();
          final Promise<Action> response =
              msgClient.phoneConfirmation(
                  data,
                  contextProvider
                      .getDecisionContext()
                      .getWorkflowContext()
                      .getWorkflowExecution()
                      .getWorkflowId());
          final OrPromise confirmOrTimer =
              new OrPromise(startDaemonTimer(confirmationPeriod), response);
          new TryCatch() {
            @Override
            protected void doTry() throws Throwable {
              setConfirm(confirm, confirmOrTimer, response, data);
            }

            @Override
            protected void doCatch(Throwable e) throws Throwable {
              data.setAction(Action.TIMEOUT);
              msgClient.sendMessage(data);
              cancel(e);
            }
          };
          handleVoice(confirm);
        } else if (data.getAction() == Action.DEPOSIT_CONF
            || data.getAction() == Action.DEPOSIT_NOT) {
          Withdrawal w = (Withdrawal) data.getPayload();
          Promise<BigDecimal> balance = null;
          if (w.getBalance() == null) {
            balance = bcdClient.getAccountBalance(data.getCn());
          }
          Promise<BigDecimal> fee = null;
          if (w.getFee() == null) {
            fee = msgClient.readAccountFee(data.getCn());
          }
          if (data.getTo() == null) {
            respondDepositConfMessage(balance, fee, msgClient.readMessageAddress(data));
          } else {
            Settable<DataSet> ds = new Settable<>();
            respondDepositConfMessage(balance, fee, ds);
            ds.set(data);
          }
        } else {
          throw new RuntimeException("unknown action");
        }
      }

      @Override
      protected void doCatch(Throwable e) throws Throwable {
        data.setAction(Action.UNAVAILABLE);
        msgClient.sendMessage(data);
        e.printStackTrace();
        cancel(e);
      }
    };
  }

  @Asynchronous
  public void handleVoice(Promise<DataSet> rsp) {
    msgClient.sendMessage(rsp.get());
  }

  @Asynchronous
  public void setConfirm(
      @NoWait Settable<DataSet> account,
      OrPromise trigger,
      Promise<Action> isConfirmed,
      DataSet data)
      throws Throwable {
    if (isConfirmed.isReady()) {
      if (null != isConfirmed.get() && isConfirmed.get() != Action.WITHDRAWAL_REQ) {
        data.setAction(isConfirmed.get());
      }
      account.set(data);
    } else {
      throw new Throwable("user did not confirm transaction.");
    }
  }

  @Asynchronous
  public void createAddress(Promise<Void> done, DataSet data) {
    Promise<String> bcAddress = bcdClient.getNewAddress(data.getCn());
    respondDataReq(bcAddress, data);
  }

  @Asynchronous(daemon = true)
  private Promise<Void> startDaemonTimer(int seconds) {
    Promise<Void> timer = clock.createTimer(seconds);
    return timer;
  }

  @Asynchronous
  public void respondDepositReq(Promise<String> bcAddress, DataSet data) {
    data.setPayload(
        new PaymentAddress().setAddress(bcAddress.get()).setAddressType(PaymentType.BTC));
    msgClient.sendMessage(data);
  }

  @Asynchronous
  public void respondDataReq(Promise<String> bcAddress, DataSet data) {
    data.setPayload(
        new PaymentAddress().setAddress(bcAddress.get()).setAddressType(PaymentType.BTC));
    msgClient.putAddressCache(data);
  }

  @Asynchronous
  public void respondBalance(Promise<BigDecimal> balance, Promise<BigDecimal> fee, DataSet data) {
    data.setPayload(new Withdrawal().setBalance(balance.get().subtract(fee.get())));
    msgClient.sendMessage(data);
  }

  @Asynchronous
  public void cacheBalance(Promise<BigDecimal> balance, DataSet data) {
    data.setPayload(new Withdrawal().setBalance(balance.get()));
    msgClient.putCache(data);
  }

  @Asynchronous
  public void respondTransactions(Promise<List<Transaction>> transactions, DataSet data) {
    data.setPayload(transactions.get());
    msgClient.sendMessage(data);
  }

  @Asynchronous
  public void respondDepositConfMessage(
      Promise<BigDecimal> balance, Promise<BigDecimal> fee, Promise<DataSet> addr) {
    DataSet ds = addr.get();
    Withdrawal dep = (Withdrawal) ds.getPayload();
    BigDecimal bal = (dep.getBalance() != null) ? dep.getBalance() : balance.get();
    BigDecimal f = (dep.getFee() != null) ? dep.getFee() : fee.get();
    dep.setBalance(bal.subtract(f));
    msgClient.sendMessage(ds);
  }
}