Step 8 - Challenge: Persistence | Step 8 - Persistence | Build Your Own Redis Server (Python Edition) | Products | Coding Challenges

Step 8 - Challenge: Persistence

Step 8 - Challenge: Persistence

In this step your goal is to make your Redis server persist its internal state to disk and to reload the state on startup.

For this step we will implement the AOF (Append Only File). In this mode the Redis server logs every operation received by the server to disk. These operations can then be replayed on startup to re-create the current status of the stored dataset.

The commands are logged in the same format as the Redis protocol itself.

Build Your Own Redis Server (Python Edition)

Buy nowLearn more

Introduction

Introduction

Learn About Redis

Step 0 - Setting Up

Step Goals

Installing Redis

Setting Up Python

Learn To Use Redis, Redis CLI And Redis Benchmark

Create A GitHub Repo For Your Project.1

Step 1 - Introduction to RESP, Building a Protocol Handler Using Test-Driven Development

Introduction to RESP

Introduction to Test Driven Development

Using Test Driven Development to Build a Protocol Handler

Step 1 - Challenge: Protocol Handling

Step 1 - Solution: Protocol Handling5

Step 2 - Creating a Network Client and Server

Introduction To Creating A Network Client And Server4

Serialising the RESP Data Types2

Building a Simple Redis CLI

Testing the CLI Against Redis

Sample Solution for a Simple Redis CLI8

Step 2 - Challenge: Handling PING and ECHO Commands

Building a Simple Server To Handle Incoming Connections

Responding To The PING And ECHO Commands

Step 2 - Solution: Handling PING and ECHO Commands3

Step 3 - Data Structures, Set and Get

Set Up Continuous Integration

Step 3 - Challenge: SET and GET

Adding The Core Data Structure

Handling The Set Command

Handling the Get command

Using the Redis CLI to test Set and Get

Step 3 - Solution: SET and GET4

Step 4 - Handling Concurrency

Step 4 - Challenge: Handling Concurrent Clients1

Threads Versus Async

Making The Data Store Thread-Safe

Handling Concurrent Clients With Threads

Using The Redis CLI And Redis Benchmark To Test Concurrency

Step 4 - Solution: Handling Concurrent Clients With Threads

Step 4 - Async Solution: Handling Concurrent Clients With Async IO2

Step 5 - Implementing Expiry

Introducing The Two Methods Of Expiry

Step 5 - Challenge: Implementing Key Expiry

Updating The Data Store And Set Command Handler Ready For Expiry

Implementing Expire On Read2

Implementing Background Expiry

Step 5 - Solution: Implementing Key Expiry (Common Parts)1

Step 5 - Solution: Implementing Key Expiry Using Threads

Step 5 - Solution: Implementing Key Expiry Asynchronously

Step 6 - Implementing More Commands

Step 6 - Challenge: Adding More Commands2

Impelenting EXISTS and DEL

Implementing INCR and DECR3

Implementing LPUSH, RPUSH And LRANGE2

Step 6 - Solution: Adding More Commands2

Step 7 - Performance

Step 7 - Challenge: Performance Optimisation and Benchmarking

Benchmarking Your Server

How To Optimise For Performance

Performance Tuning The Server3

Step 8 - Persistence

Step 8 - Challenge: Persistence

Persisting The Database

Loading The Database

Step 8 - Solution: Persistence

Closing Remarks

The Complete Final Solution

Going Further

Wrapping Up