waiter | Delayed iteration for polling and retries | Automation library

The selection parameter of Picker will do the work of storing the tip amount for you -- there's no need for the tipSelected = line of imperative code.

Then, unless you're planning on mutating them somewhere, the if_10 and if_20 don't really need to be @State variables.

Here's one possible solution:

The idea is this: You start another async-computation (in the background) with let wait = Async.StartChild otherComp and you get the waiter back.

What that means is that let! result = waiter will block and wait for the result of your background-computation whenever you want.

if Async.StartChild would return a Async<'t> you would wait with let! x = otherComp right there and it would be just like a normal let! result = otherComp`

And yes F# Async-Workflows will only start once you do something like Async.Start... or Async.RunSynchronously (it's not like a Task that usually runs as soon as you created it)

that's why in C# you can create a Task (var task = CreateMyTask()) at one point (that would be the Async.StartChild part) and then later use var result = await task to wait there for the result (that's the let! result = waiter part).

This is because the workflows started this way is supposed to behave like a child-task/process. When you cancel the containing workflow the child should be canceled as well.

So on a technical level the child-workflow needs access to the cancelation-token without you passing it explicitly and that is one thing the Async-Type handles in the background for you when you use Bind (aka let! here).

So it has to be this type in order for that passing of the cancelation-token to work.

Could it be that your waiter is actually checking the existing db and seeing that it's available before the status can update on the previous command to restore the snapshot?

You need to call functions like below:-

Sadly you can't do this. Delimiter in Join must be explicit string.

For the Fn::Join delimiter, you can't use any functions. You must specify a string value.

So you can't use Sub in Delimiter.

The only way would to create a custom macro or a custom resource in CloudFormation. In both ways, you would need to develop a lambda function to handle the transformation of your data to desired format.

This just looks like some misrepresentation in the graphical representation.

process1c096e1d088 (the UPDATE) holds a page level X lock on page 1502 and a page level U lock on 1503 and is trying to convert that U lock to an X lock. (requestType="convert")

process1c094ee5468 (the SELECT) holds a page level S lock on 1503 (compatible with the U lock) and is waiting for a page level S lock on 1502.

Because the page lock 1503 is held in both S and U modes it has mode="U" in the deadlock XML and the UI assumes it is held by the blocker in that mode.

Of course if the SELECT transaction was to release its lock on 1503 before requesting the lock on 1502 this deadlock could not arise but I assume there is a good reason for it not doing this (maybe to stop 1502 getting deallocated mid scan and leaving it with no next page to visit).

Could you check your Compute Engine default service account to check if it’s enabled and if it has the correct permissions?

The default Compute Engine has the below format:

PROJECT_NUMBER-compute@developer.gserviceaccount.com

Related:

https://community.bitnami.com/t/deployment-failed/59625

https://groups.google.com/g/gce-discussion/c/Nr45fqKdGU4

Edit: For the permission in the SA, you need to wait a bit so the permissions can be propagated "may take up to 7 minutes for these changes to fully propagate across the system", reference.

Figured it out (at least enough for my use case).

It seems that my issue was a misunderstanding with the how the multiprocessing Pool is meant to work. It seems that "in multiprocessing, an interpreter is created for every child process. The situation where threads fighting for GIL simple doesn’t exist as there is always only a main thread in every process" ¹. (The GIL is explained in the article.)

This would be helpful if my code was CPU bound, but since I am I/O bound, "threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously" ². This seems to apply.

It seems that since multiprocessing has many interpreters they weren't able to share whatever rpc connection the Google logging library uses, causing it to fail.

I was able to find another SO question that references a Thread Pool API in Python that uses threads instead of multiple processes.

Using this along with Locks I was able to solve my issue!

[1] https://hackernoon.com/concurrent-programming-in-python-is-not-what-you-think-it-is-b6439c3f3e6a

[2] https://docs.python.org/3/library/threading.html#threading.Thread