concurrently | Like npm run watch | Command Line Interface library

I am trying to perform a series of network requests and would like to limit the number of concurrent tasks in the new Swift Concurrency system. With operation queues we would use maxConcurrentOperationCount. In Combine, flatMap(maxPublishers:_:). What is the equivalent in the new Swift Concurrency system?

E.g., it is not terribly relevant, but consider:

Question in short

I have migrated my project from Django 2.2 to Django 3.2, and now I want to start using the possibility for asynchronous views. I have created an async view, setup asgi configuration, and run gunicorn with a Uvicorn worker. When swarming this server with 10 users concurrently, they are served synchronously. What do I need to configure in order to serve 10 concurrent users an async view?

Question in detail

This is what I did so far in my local environment:

• I am working with Django 3.2.10 and Python 3.9.
• I have installed gunicorn and uvicorn through pip
• I have created an asgi.py file with the following contents

I am writing a lambda function that takes a list of CW Log Groups and runs an "export to s3" task on each of them.

I am writing automated tests using pytest and I'm using moto.mock_logs (among others), but create_export_tasks() is not yet implemented (NotImplementedError).

To continue using moto.mock_logs for all other methods, I am trying to patch just that single create_export_task() method using mock.patch, but it's unable to find the correct object to patch (ImportError).

I successfully used mock.Mock() to provide me just the functionality that I need, but I'm wondering if I can do the same with mock.patch()?

Working Code: lambda.py

I'm having an issue where two concurrent processes are updating a DynamoDB table within 5ms of each other and both pass the conditional expression when I expect one to throw the ConditionalCheckFailedException exception. Documentation states:

DynamoDB supports mechanisms, like conditional writes, that are necessary for distributed locks.

https://aws.amazon.com/blogs/database/building-distributed-locks-with-the-dynamodb-lock-client/

My table schema has a single Key attribute called "Id":

I need to have a global boolean flag that will be accessed by multiple threads.

Here is an example of what I need:

Let's say I want to download two web pages concurrently with Tokio...

Either I could implement this with tokio::spawn():

I'm having trouble wrapping my head around the dichotomy of DDB providing Condition Writes but also being eventually consistent. These two truths seem to be at odds with each other.

In the classic scenario, user Bob updates key A and sets the value to "FOO". User Alice reads from a node that hasn't received the update yet, and so it gets the original value "BAR" for the same key.

If Bob and Alice write to different nodes on the cluster without condition checks, it's possible to have a conflict where Alice and Bob wrote to the same key concurrently and DDB does not know which update should be the latest. This conflict has to be resolved by the client on next read.

But what about when condition write are used?

User Bob sends their update for A as "FOO" if the existing value for A is "BAR". User Alice sends their update for A as "BAZ" if the existing value for A is "BAR".

Locally each node can check to see if their node has the original "BAR" value and go through with the update. But the only way to know the true state of A across the cluster is to make a strongly consistent read across the cluster first. This strongly consistent read must be blocking for either Alice or Bob, or they could both make a strongly consistent read at the same time.

So here is where I'm getting confused about the nature of DDBs condition writes. It seems to me that either:

1. Condition writes are only evaluated locally. Merge conflicts can still occur.
2. Condition writes are evaluated cross cluster.

If it is #2, the only way I see that working is if:

1. A lock is created for the key.
2. A strongly consistent read is made.

Let's say it's #2. Now where does this leave Bob's update? The update was made to node 2 and sent to node 1 and we have a majority quorum. But to make those updates available to Alice when they do their own conditional write, those updates need to be flushed from WAL. So in a conditional write are the updates always flushed? Are writes always flushed in general?

There have been other questions like this here on SO but the answers were a repeat of, or a link to, the AWS documentation about this. The AWS documentation doesn't really explain this (or i missed it).

This question is somehow related to my last question, because it is the same project but now I am trying to go one more step forward.

So, in my previous question I only had one table; this time I have two tables: the new second table is supposed to contain related attributes for the rows of the first table, in a OneToMany relationship. So, I store a ForeignKey in the second table that would store the Row ID of the first table's related row (obviously).

The problem is this: the intention is creating both registers (parent and child) at the same time, using the same form, and ParentTable uses AUTO_INCREMENT for his PrimaryKey (AKA ID).

Due to how RoomDb works, I do the creation using a POJO: but after insertion, this POJO won't give me the auto-generated ID as far as I know... so, the only workaround I am able to imagine is, when submitting the form, first make the INSERT for the parent, then using one of the form's fields that created the parent to make some kind of "SELECT * FROM parent_table WHERE field1 LIKE :field1", retrieving the ID, and then use that ID to create the child table's POJO and perform the next INSERT operation. However I feel something's not right about this approach, the last time I implemented something similar this way I ended up with a lot of Custom Listeners and a callback hell (I still have nightmares about that).

About the Custom Listeners thing, it is the solution I ended up choosing for a different problem for a different project (more details about it in this old question). Taking a look to that old question might help adding some context about how misguided I am in MVVM's architecture. However, please notice the current question has nothing to do with WebServices, because the Database is purely local in the phone's app, no external sources.

However, I am wondering: isn't this overkill (I mean the INSERT parent -> SELECT parentID -> INSERT child thing)? Is it inevitable having to do it this way, or there is rather a more clean way to do so?

The "create method" in my Repository class looks like this:

I'm enumerating ConcurrentDictionary, I need to be sure I don't miss any initial item. In other words, I need to be sure I enumerate all initial items.

Initial items: all items in dictionary when the enumeration starts.

The documentation says:

The enumerator returned from the dictionary is safe to use concurrently with reads and writes to the dictionary, however it does not represent a moment-in-time snapshot of the dictionary. The contents exposed through the enumerator may contain modifications made to the dictionary after

But it is not clear if all initial items are enumerated. So I tested it with the following code: