Distributted Locking Mechanism AWS DynamoDB with Python - python-3.x

Question

I'm working on a project in which I have two actions - delete and write, and I need to make them "atomic", i.e., to be performed without any other process reading from the database after the data was deleted but not yet written.
The code under the Concept Demonstration rubric demonstrates the desired outcome with the use of multiprocessing.Process and multiprocessing.Pipe objects:
Concept Demonstration:
import time
from datetime import datetime
import boto3
from multiprocessing import Process, Pipe
from boto3.dynamodb.conditions import Key, Attr
def write_and_del_dynamodb(lock_pipe):
_, lck_snd = lock_pipe
dynamodb = boto3.client("dynamodb")
add_params = {
"TableName": "Testing",
"Item": {
"stream_url": {"S": "stream_url_test"},
"added_time_utc": {"S": str(datetime.utcnow())},
"ConditionExpression": 'attribute_not_exists(stream_url)'
}
del_params = {
"TableName": "Testing",
"Key": {'stream_url': {"S": 'stream_url_test'}}
}
lck_snd.send('LOCK_DOWN')
print('''
================ ATOMIC WRITE-DELETE-WRITE PROCESS ====================
''')
print('Putting an item...')
dynamodb.put_item(**add_params)
print('Sleeping for 1s...')
time.sleep(1)
print("Deleting an item...")
dynamodb.delete_item(**del_params)
print('Sleeping for 3s...')
time.sleep(3)
print('Putting an item...')
dynamodb.put_item(**add_params)
print('''
================ ATOMIC WRITE-DELETE-WRITE PROCESS ====================
''')
lck_snd.send('LOCK_UP')
def read_dynamodb(lock_pipe):
lck_rcv, _ = lock_pipe
dynamodb = boto3.client("dynamodb")
params = {
"TableName": "Testing",
"Key": {'stream_url': {"S": 'stream_url_test'}}
}
while lck_rcv.recv() != 'LOCK_UP':
pass
db_response = dynamodb.get_item(**params)
items = db_response.get('Item')
print(f'''
================ READ PROCESS ====================
Data read:
{items}
================ READ PROCESS ====================
''')
if __name__ == '__main__':
lock_pipe_receive, lock_pipe_send = Pipe()
Process(name="write_and_del_dynamodb", target=write_and_del_dynamodb, args=((lock_pipe_receive, lock_pipe_send),)).start()
time.sleep(1)
Process(name="read_dynamodb", target=read_dynamodb, args=((lock_pipe_receive, lock_pipe_send),)).start()
in the code above two processes share the same resource, i.e., the dynamoDB data table Testing.
The working principle:
First process starts by sending a 'LOCK_DOWN' on the lock_pipe_send end, to signify the start of an atomic procedure.
First process writes some data to the dynamoDB.
First process deletes the data from the dynamoDB.
First process writed the data to the dynamoDB again.
The first process sends the 'LOCK_UP' on the lock_pipe_send end to signal the second process that the data may be read.
The second process (which was waiting on the while lck_rcv.recv() != 'LOCK_UP' condition) receives the LOCK_UP message, and reads the data from the dynamoDB.
My question:
How can I implement this behavior in a distributed manner, i.e., when I have the two processes sitting on different physical machines in the AWS, as shown in the following image?
Thanks in advance.