cadence | highly available orchestration engine to execute | Microservice library

I would like to put workflow.Sleep call in one of my Cadence activities to be able to test it properly (and simulate error result coming from Sleep function).

Two important things which I noticed before implementing:

• context.Context and workflow.Context are separate types.
• First parameter of each activity - context.Context - is optional and can be omitted

My tries:

1. First try

I am new to uber Cadence and trying to write a cron scheduled task. Cadence provided a cronSchedule annotation (find an example online) which takes a cron expression string for the method to be triggered at specific time. However, I want this cron expression to be loaded according to what we set in the yml file. Is there any way to do it? I currently only found this @cronSchedule annotation way to do it. I also found there is a WorkflowOption that I can set the cronSchedule. However, don't know how to use it to trigger the method. Below is the current code.

I would like to format my existing SQL queries inside the PySpark file.

This is how my existing source file looks like:

I am evaluating cadence for implementing our business orchestration. I understand that the workers continuously poll the task list for tasks to execute. My concern here is that will it cause any scale problems? The worker is always busy and continuously polling some database, along with this it also needs to execute the business logic so is there a possibility that it runs out of resources and then crashes or drops the tasks to execute?

How does this polling mechanism scale when we have millions of workflows? Will it cause delays in executing the workflow code, when we have millions of tasks in the task list?

I am working on setting up my Android app to work with HTTP Web Links according to the various guides and protocols and have successfully setup the deeplinks which includes serving my assetlinks file from /.well-known/assetlinks.json. Everything is working as expected. What I am struggling with from an operational perspective is how to go about maintaining this file -- specifically during update and failure scenarios.

Let's say I have existing customers who have downloaded my app and are using weblinks just fine. I update my assetlink file and push the new version to my server. When do my customers get the updated assetlink file? Is the OS configured to check for updates on some cadence or app launch? Is it only on app update or reinstall?

Similarly, imagine my website is down. New users are installing my app and the OS will not be able to associate my domain and when customers click the HTTP web links they will not be deeplinked into the app. This makes sense. But after I recover from my outage when will the customer get their assetlink file given the app is already installed?

Similarly lets say I upload an invalid assetlinks.json file. Will this break the current web links for existing customers who already had a valid association when they first installed the app?

Understanding these issues will ultimately help me better troubleshoot customer issues and tune the expected traffic I should expect to see for my assetlinks file from my server.

In cadence a resource interface can contain state and methods that needs to be implemented. However when I try to indent a cadence file in vim it will indent the code wrong.

In current application, we have three services:

• invoice
• bank transfer : calls external API, which might takes a minute or so depends on queue
• ledger : internal microservice that create debit-credit ledger

To communicate, we have an orchestration saga. The flow is basically using invoice as the orchestrator:

1. invoice service publish message to rabbitmq, asking payment for invoice X
2. bank transfer service listen message, get invoice X
3. bank transfer service process the transfer (calls bank's API). When payment success, publishing message to rabbitmq that 'Invoice X paid'
4. invoice service listen the message 'Invoice X paid'
5. Invoice service publish message 'Create ledger for invoice X' and publish to rabbitmq
6. ledger service listen from rabbitmq for message 'Create ledger for invoice X'
7. ledger service create appropriate ledger journal debit / credit, then publish 'ledger created for invoice X'
8. Invoice service listen for message 'ledger created for invoice X', then finalize (close) the transaction

Question 1 If I'm using Temporal or cadence (just looking for it), they doesn't rely on pub-sub pattern like above. So how do I implement it?

I'm thinking (CMIIW) :

• create InvoiceActivity
• create BankTransferActivity
• create LedgerActivity
• create InvoicePaymentWorkflow

All of those Workflow and Activity are part of invoice service app. But instead of relying on pub-sub, the bank transfer service and ledger service now provides API to process transfer (in term of bank transfer, it acually a proxy API to external bank calll), and ledger service provides API to create debit/credit journal. CMIIW, in this case, we no longer need creating listener (or cadence / temporal activity) on bank transfer service and ledger service, we need to provides API.

OR I'm thinking it wrong? There should be some activity on bank transfer service and ledger service? But if so, how can the invoice service trigger and arrange the workflow?

Question 2 But now the call is asynchronous. The journal ledger creation actually has some validation, and heavy load at times, so depends on message on queues, it can take up to 5 minutes from the message goes to rabbitmq until journal actually created. On API call, this will be a timeout.

Question 3 And what about the race condition? Some journals to be created in sequence. Using rabbitmq, we can achieve this with certain technique (single consumer on queue, something like kafka topic).

Question 4 Also, how to handle the compensating transaction? If ledger failed, we must do something. In our case, we must notify somebody on accounting, since bank transfer already processed and cannot reversed.

Question 5 For some subsidiariy companies, when ledger failed, we still has control, so we can compensate / withdraw the invoice amount, and return the amount back to parent company. Suppose we have a listener for this on the bank transfer service, how can we trigger the compensation API?

In cadence / Temporal, is this suitable usecase? If so, how to handle those issues above?

Thanks

I'm trying to understand about case between same extended class in uvm as example below,