Distributed Lock API updates (#2591)

* lock API files

Signed-off-by: msfussell <markfussell@gmail.com>

* lock API files

Signed-off-by: msfussell <markfussell@gmail.com>

* lock API files update

Signed-off-by: msfussell <markfussell@gmail.com>

* lock API files update overview

Signed-off-by: msfussell <markfussell@gmail.com>

* lock API files update overview

Signed-off-by: msfussell <markfussell@gmail.com>

* lock API files update buidling block

Signed-off-by: msfussell <markfussell@gmail.com>

* lock API files update overview

Signed-off-by: msfussell <markfussell@gmail.com>

* Update daprdocs/content/en/developing-applications/building-blocks/distributed-lock/distributed-lock-api-overview.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/developing-applications/building-blocks/distributed-lock/distributed-lock-api-overview.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/developing-applications/building-blocks/distributed-lock/distributed-lock-api-overview.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/developing-applications/building-blocks/distributed-lock/distributed-lock-api-overview.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Update daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

* Updates to Redis metadata and overview

Co-authored-by: Hannah Hunter <94493363+hhunter-ms@users.noreply.github.com>

daprdocs/content/en/concepts/building-blocks-concept.md

@@ -23,8 +23,9 @@ The following are the building blocks provided by Dapr:
 | [**Service-to-service invocation**]({{<ref "service-invocation-overview.md">}}) | `/v1.0/invoke` | Service invocation enables applications to communicate with each other through well-known endpoints in the form of http or gRPC messages. Dapr provides an endpoint that acts as a combination of a reverse proxy with built-in service discovery, while leveraging built-in distributed tracing and error handling.
 | [**State management**]({{<ref "state-management-overview.md">}}) | `/v1.0/state` | Application state is anything an application wants to preserve beyond a single session. Dapr provides a key/value-based state and query APIs with pluggable state stores for persistence.
 | [**Publish and subscribe**]({{<ref "pubsub-overview.md">}}) | `/v1.0/publish` `/v1.0/subscribe`|  Pub/Sub is a loosely coupled messaging pattern where senders (or publishers) publish messages to a topic, to which subscribers subscribe. Dapr supports the pub/sub pattern between applications.
-| [**Resource bindings**]({{<ref "bindings-overview.md">}}) | `/v1.0/bindings` | A binding provides a bi-directional connection to an external cloud/on-premise service or system. Dapr allows you to invoke the external service through the  Dapr binding API, and it allows your application to be triggered by events sent by the connected service.
+| [**Bindings**]({{<ref "bindings-overview.md">}}) | `/v1.0/bindings` | A binding provides a bi-directional connection to an external cloud/on-premise service or system. Dapr allows you to invoke the external service through the  Dapr binding API, and it allows your application to be triggered by events sent by the connected service.
 | [**Actors**]({{<ref "actors-overview.md">}}) | `/v1.0/actors` |  An actor is an isolated, independent unit of compute and state with single-threaded execution. Dapr provides an actor implementation based on the virtual actor pattern which provides a single-threaded programming model and where actors are garbage collected when not in use.
 | [**Observability**]({{<ref "observability-concept.md">}}) | `N/A` |  Dapr system components and runtime emit metrics, logs, and traces to debug, operate and monitor Dapr system services, components and user applications.
 | [**Secrets**]({{<ref "secrets-overview.md">}}) | `/v1.0/secrets` | Dapr provides a secrets building block API and integrates with secret stores such as public cloud stores, local stores and Kubernetes to store the secrets. Services can call the secrets API to retrieve secrets, for example to get a connection string to a database.
-| [**Configuration**]({{<ref "configuration-api-overview.md">}}) | `/v1.0-alpha1/configuration` | Dapr provides a Configuration API that enables you to retrieve and subscribe to application configuration items for supported configuration stores. This enables an application to retrieve specific configuration information, for example, at start up or when configuration changes are made in the store. 
+| [**Configuration**]({{<ref "configuration-api-overview.md">}}) | `/v1.0-alpha1/configuration` | The Configuration API enables you to retrieve and subscribe to application configuration items for supported configuration stores. This enables an application to retrieve specific configuration information, for example, at start up or when configuration changes are made in the store. 
+| [**Distributed lock**]({{<ref "distributed-lock-api-overview.md">}}) | `/v1.0-alpha1/lock` | The distributed lock API enables you to take a lock on a resource so that multiple instances of an application can access the resource without conflicts and provide consistency guarantees.

daprdocs/content/en/concepts/components-concept.md

@@ -18,6 +18,9 @@ Each component has a specification (or spec) that it conforms to. Components are
 
 It is important to understand that the component spec values, particularly the spec `metadata`, can change between components of the same component type, for example between different state stores, and that some design-time spec values can be overridden at runtime when making requests to a component's API. As a result, it is strongly recommended to review a [component's specs]({{<ref "components-reference">}}), paying particular attention to the sample payloads for requests to set the metadata used to interact with the component.
 
+The diagram below shows some examples of the components for each component type
+<img src="/images/concepts-components.png" width=1200>
+
 ## Available component types
 
 The following are the component types provided by Dapr:
@@ -64,6 +67,13 @@ Configuration stores are used to save application data, which can then be read b
 - [List of supported configuration stores]({{< ref supported-configuration-stores >}})
 - [Configuration store implementations](https://github.com/dapr/components-contrib/tree/master/configuration)
 
+### Locks
+
+Lock components are used as a distributed lock to provide mutually exclusive access to a resource such as a queue or database.
+
+- [List of supported locks]({{< ref supported-locks >}})
+- [Lock implementations](https://github.com/dapr/components-contrib/tree/master/lock)
+
 ### Middleware
 
 Dapr allows custom [middleware]({{<ref "middleware.md">}})  to be plugged into the HTTP request processing pipeline. Middleware can perform additional actions on an HTTP request, such as authentication, encryption and message transformation before the request is routed to the user code, or before the response is returned to the client. The middleware components are used with the [service invocation]({{<ref "service-invocation-overview.md">}}) building block.

daprdocs/content/en/concepts/overview.md

@@ -43,6 +43,7 @@ Each of these building block APIs is independent, meaning that you can use one,
 |  [**Observability**]({{<ref "observability-concept.md">}}) | Dapr emits metrics, logs, and traces to debug and monitor both Dapr and user applications. Dapr supports distributed tracing to easily diagnose and serve inter-service calls in production using the W3C Trace Context standard and Open Telemetry to send to different monitoring tools.
 | [**Secrets**]({{<ref "secrets-overview.md">}}) | The secrets management API integrates with public cloud and local secret stores to retrieve the secrets for use in application code.
 | [**Configuration**]({{<ref "configuration-api-overview.md">}})  | The configuration API enables you to retrieve and subscribe to application configuration items from configuration stores. 
+| [**Distributed lock**]({{<ref "distributed-lock-api-overview.md">}})  | The distributed lock API enables your application to aquire a lock for any resource that gives it exclusive access until either the lock is released by the application, or a lease timeout occurs. 
 
 ## Sidecar architecture
 
@@ -60,7 +61,7 @@ In [self-hosted mode]({{< ref self-hosted-overview.md >}}) Dapr runs as a separa
 
 You can use the [Dapr CLI](https://github.com/dapr/cli#launch-dapr-and-your-app) to run a Dapr-enabled application on your local machine. The diagram below show Dapr's local development environment when configured with the CLI `init` command. Try this out with the [getting started samples]({{< ref getting-started >}}). 
 
-<img src="/images/overview_standalone.png" width=1200 alt="Architecture diagram of Dapr in self-hosted mode">
+<img src="/images/overview-standalone.png" width=1200 alt="Architecture diagram of Dapr in self-hosted mode">
 
 ### Kubernetes
 
@@ -72,7 +73,7 @@ The `dapr-sentry` service is a certificate authority that enables mutual TLS bet
 
 Deploying and running a Dapr-enabled application into your Kubernetes cluster is as simple as adding a few annotations to the deployment schemes. Visit the [Dapr on Kubernetes docs]({{< ref kubernetes >}})
 
-<img src="/images/overview_kubernetes.png" width=1200 alt="Architecture diagram of Dapr in Kubernetes mode">
+<img src="/images/overview-kubernetes.png" width=1200 alt="Architecture diagram of Dapr in Kubernetes mode">
 
 ### Clusters of physical or virtual machines
 
@@ -107,9 +108,9 @@ Dapr can be used from any developer framework. Here are some that have been inte
 | Language | Frameworks | Description |
 |----------|------------|-------------|
 | [.NET]({{< ref dotnet >}}) | [ASP.NET Core]({{< ref dotnet-aspnet.md >}}) | Brings stateful routing controllers that respond to pub/sub events from other services. Can also take advantage of [ASP.NET Core gRPC Services](https://docs.microsoft.com/aspnet/core/grpc/).
-| [Java]({{< ref java >}}) | [Spring Boot](https://spring.io/)
-| [Python]({{< ref python >}}) | [Flask]({{< ref python-flask.md >}})
-| [Javascript](https://github.com/dapr/js-sdk) | [Express](http://expressjs.com/)
+| [Java]({{< ref java >}}) | [Spring Boot](https://spring.io/) | Build Spring boot applications with Dapr APIs
+| [Python]({{< ref python >}}) | [Flask]({{< ref python-flask.md >}}) | Build Flask applications with Dapr APIs
+| [Javascript](https://github.com/dapr/js-sdk) | [Express](http://expressjs.com/) | Build Express applications with Dapr APIs
 | [PHP]({{< ref php >}}) | | You can serve with Apache, Nginx, or Caddyserver.
 
 #### Integrations and extensions

daprdocs/content/en/developing-applications/building-blocks/configuration/configuration-api-overview.md

@@ -14,9 +14,9 @@ Consuming application configuration is a common task when writing applications a
 
 It is worth noting that this configuration API should not be confused with the [Dapr sidecar and control plane configuration]({{<ref "configuration-overview">}}) which is used to set policies and settings on instances of Dapr sidecars or the installed Dapr control plane.
 
-## Features
+*This API is currently in `Alpha` state*
 
-*This API is currently in `Alpha` state and only available on gRPC. An HTTP1.1 supported version with this URL syntax `/v1.0/configuration` will be available before the API is certified into `Stable` state.*
+## Features
 
 ## Next steps
 Follow these guides on:

daprdocs/content/en/developing-applications/building-blocks/distributed-lock/_index.md

@@ -0,0 +1,7 @@
+---
+type: docs
+title: "Distributed lock"
+linkTitle: "Distributed lock"
+weight: 90
+description: Distributed locks provide mutually exclusive access to shared resources from an application.
+---

daprdocs/content/en/developing-applications/building-blocks/distributed-lock/distributed-lock-api-overview.md

@@ -0,0 +1,43 @@
+---
+type: docs
+title: "Distributed lock overview"
+linkTitle: "Overview"
+weight: 1000
+description: "Overview of the distributed lock API building block"
+---
+
+## Introduction
+Locks are used to provide mutually exclusive access to a resource. For example, you can use a lock to:
+
+- Provide exclusive access to a database row, table, or an entire database
+- Lock reading messages from a queue in a sequential manner
+
+Any resource that is shared where updates occur can be the target for a lock. Locks are usually used on operations that mutate state, not on reads.
+
+Each lock has a name. The application determines the resources that the named lock accesses. Typically, multiple instances of the same application use this named lock to exclusively access the resource and perform updates. 
+
+For example, in the competing consumer pattern, multiple instances of an application access a queue. You can decide that you want to lock the queue while the application is running its business logic.
+
+In the diagram below, two instances of the same application, `App1`, use the [Redis lock component]({{< ref redis-lock >}}) to take a lock on a shared resource. 
+
+- The first app instance acquires the named lock and gets exclusive access. 
+- The second app instance is unable to acquire the lock and therefore is not allowed to access the resource until the lock is released, either:
+   - Explicitly by the application through the unlock API, or 
+   - After a period of time, due to a lease timeout. 
+
+<img src="/images/lock-overview.png" width=900>
+
+*This API is currently in `Alpha` state.
+
+## Features
+
+### Mutually exclusive access to a resource
+At any given moment, only one instance of an application can hold a named lock. Locks are scoped to a Dapr app-id.
+
+### Deadlock free using leases
+Dapr distributed locks use a lease-based locking mechanism. If an application acquires a lock, encounters an exception, and cannot free the lock, the lock is automatically released after a period of time using a lease. This prevents resource deadlocks in the event of application failures.
+
+## Next steps
+Follow these guides on:
+- [How-To: Use distributed locks in your application]({{< ref howto-use-distributed-lock.md >}})
+

daprdocs/content/en/developing-applications/building-blocks/distributed-lock/howto-use-distributed-lock.md

@@ -0,0 +1,66 @@
+---
+type: docs
+title: "How-To: Use a lock"
+linkTitle: "How-To: Use a lock"
+weight: 2000
+description: "Learn how to use distributed locks to provide exclusive access to a resource"
+---
+
+Now that you've learned what the Dapr distributed lock API building block provides, learn how it can work in your service. The example below describes an application that aquires a lock. This example uses the Redis lock component to demonstrate how to lock resources.
+
+<img src="/images/building-block-lock-example.png" width=1000 alt="Diagram showing aquiring a lock from multiple instances of same application">
+<img src="/images/building-block-lock-unlock-example.png" width=1000 alt="Diagram showing releasing a lock from multiple instances of same application">
+<img src="/images/building-block-lock-multiple-example.png" width=1000 alt="Diagram showing aquiring multiple locks from different applications">
+
+### Configure a lock component
+
+Save the following component file to the [default components folder]({{< ref "install-dapr-selfhost.md#step-5-verify-components-directory-has-been-initialized" >}}) on your machine.
+
+```yaml
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: lock
+spec:
+  type: lock.redis
+  metadata:
+  - name: redisHost
+    value: localhost:6379
+  - name: redisPassword
+    value: <PASSWORD>
+```
+
+### Get configuration items using Dapr SDKs
+
+{{< tabs Dotnet Java Python>}}
+
+{{% codetab %}}
+
+```csharp
+
+```
+
+{{% /codetab %}}
+
+{{% codetab %}}
+
+```java
+
+```
+
+{{% /codetab %}}
+
+{{% codetab %}}
+
+```python
+
+```
+
+{{% /codetab %}}
+
+{{< /tabs >}}
+
+
+## Next steps
+
+* Read [distributed lock API overview]({{< ref distributed-lock-api-overview.md >}})

daprdocs/content/en/reference/components-reference/supported-configuration-stores/redis-configuration-store.md

@@ -58,7 +58,7 @@ The above example uses secrets as plain strings. It is recommended to use a secr
 
 ## Setup Redis
 
-Dapr can use any Redis instance - containerized, running on your local dev machine, or a managed cloud service.
+Dapr can use any Redis instance: containerized, running on your local dev machine, or a managed cloud service.
 
 {{< tabs "Self-Hosted" "Kubernetes" "Azure" "AWS" "GCP" >}}
 
@@ -67,7 +67,7 @@ A Redis instance is automatically created as a Docker container when you run `da
 {{% /codetab %}}
 
 {{% codetab %}}
-We can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Kubernetes cluster. This approach requires [Installing Helm](https://github.com/helm/helm#install).
+You can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Kubernetes cluster. This approach requires [Installing Helm](https://github.com/helm/helm#install).
 
 1. Install Redis into your cluster. Note that we're explicitly setting an image tag to get a version greater than 5, which is what Dapr' pub/sub functionality requires. If you're intending on using Redis as just a state store (and not for pub/sub), you do not have to set the image version.
     ```bash
@@ -82,8 +82,8 @@ We can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Ku
         - name: redisHost
           value: redis-master:6379
     ```
-4. Next, we'll get the Redis password, which is slightly different depending on the OS we're using:
-    - **Windows**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" > encoded.b64`, which will create a file with your encoded password. Next, run `certutil -decode encoded.b64 password.txt`, which will put your redis password in a text file called `password.txt`. Copy the password and delete the two files.
+4. Next, get the Redis password, which is slightly different depending on the OS we're using:
+    - **Windows**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" > encoded.b64`, which creates a file with your encoded password. Next, run `certutil -decode encoded.b64 password.txt`, which will put your redis password in a text file called `password.txt`. Copy the password and delete the two files.
 
     - **Linux/MacOS**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" | base64 --decode` and copy the outputted password.
 
@@ -98,13 +98,19 @@ We can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Ku
 {{% codetab %}}
 **Note**: this approach requires having an Azure Subscription.
 
-1. Open [this link](https://ms.portal.azure.com/#create/Microsoft.Cache) to start the Azure Cache for Redis  creation flow. Log in if necessary.
+1. [Start the Azure Cache for Redis creation flow](https://ms.portal.azure.com/#create/Microsoft.Cache). Log in if necessary.
 2. Fill out necessary information and **check the "Unblock port 6379" box**, which will allow us to persist state without SSL.
 3. Click "Create" to kickoff deployment of your Redis instance.
-4. Once your instance is created, you'll need to grab the Host name (FQDN) and your access key.
-   - for the Host name navigate to the resources "Overview" and copy "Host name"
-   - for your access key navigate to "Access Keys" under "Settings" and copy your key.
-5. Finally, we need to add our key and our host to a `redis.yaml` file that Dapr can apply to our cluster. If you're running a sample, you'll add the host and key to the provided `redis.yaml`. If you're creating a project from the ground up, you'll create a `redis.yaml` file as specified in [Configuration](#configuration). Set the `redisHost` key to `[HOST NAME FROM PREVIOUS STEP]:6379` and the `redisPassword` key to the key you copied in step 4. **Note:** In a production-grade application, follow [secret management]({{< ref component-secrets.md >}}) instructions to securely manage your secrets.
+4. Once your instance is created, you'll need to grab the Host name (FQDN) and your access key:
+   - For the Host name: navigate to the resource's "Overview" and copy "Host name".
+   - For your access key: navigate to "Settings" > "Access Keys" to copy and save your key.
+5. Add your key and your host to a `redis.yaml` file that Dapr can apply to your cluster. 
+   - If you're running a sample, add the host and key to the provided `redis.yaml`. 
+   - If you're creating a project from the ground up, create a `redis.yaml` file as specified in [Configuration](#configuration). 
+   
+   Set the `redisHost` key to `[HOST NAME FROM PREVIOUS STEP]:6379` and the `redisPassword` key to the key you saved earlier. 
+   
+   **Note:** In a production-grade application, follow [secret management]({{< ref component-secrets.md >}}) instructions to securely manage your secrets.
 
 > **NOTE:** Dapr pub/sub uses [Redis Streams](https://redis.io/topics/streams-intro) that was introduced by Redis 5.0, which isn't currently available on Azure Managed Redis Cache. Consequently, you can use Azure Managed Redis Cache only for state persistence.
 {{% /codetab %}}
@@ -119,7 +125,6 @@ We can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Ku
 
 {{< /tabs >}}
 
-
 ## Related links
 - [Basic schema for a Dapr component]({{< ref component-schema >}})
 - Read [How-To: Manage configuration from a store]({{< ref "howto-manage-configuration" >}}) for instructions on how to use Redis as a configuration store.

daprdocs/content/en/reference/components-reference/supported-locks/_index.md

@@ -0,0 +1,12 @@
+---
+type: docs
+title: "Lock component specs"
+linkTitle: "Locks"
+weight: 4500
+description: The supported locks that interface with Dapr
+no_list: true
+---
+
+{{< partial "components/description.html" >}}
+
+{{< partial "components/locks.html" >}}

daprdocs/content/en/reference/components-reference/supported-locks/redis-lock.md

@@ -0,0 +1,180 @@
+---
+type: docs
+title: "Redis"
+linkTitle: "Redis"
+description: Detailed information on the Redis lock component
+---
+
+## Component format
+
+To set up the Redis lock, create a component of type `lock.redis`. See [this guide]({{< ref "howto-use-distributed-lock" >}}) on how to create a lock.
+
+```yaml
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: <NAME>
+  namespace: <NAMESPACE>
+spec:
+  type: lock.redis
+  version: v1
+  metadata:
+  - name: redisHost
+    value: <HOST>
+  - name: redisPassword
+    value: <PASSWORD>
+  - name: enableTLS
+    value: <bool> # Optional. Allowed: true, false.
+  - name: failover
+    value: <bool> # Optional. Allowed: true, false.
+  - name: sentinelMasterName
+    value: <string> # Optional
+  - name: maxRetries
+    value: # Optional
+  - name: maxRetryBackoff
+    value: # Optional
+  - name: failover
+    value: # Optional
+  - name: sentinelMasterName
+    value: # Optional
+  - name: redeliverInterval
+    value: # Optional
+  - name: processingTimeout
+    value: # Optional
+  - name: redisType
+    value: # Optional
+  - name: redisDB
+    value: # Optional
+  - name: redisMaxRetries
+    value: # Optional
+  - name: redisMinRetryInterval
+    value: # Optional
+  - name: redisMaxRetryInterval
+    value: # Optional
+  - name: dialTimeout
+    value: # Optional
+  - name: readTimeout
+    value: # Optional
+  - name: writeTimeout
+    value: # Optional
+  - name: poolSize
+    value: # Optional
+  - name: poolTimeout
+    value: # Optional
+  - name: maxConnAge
+    value: # Optional
+  - name: minIdleConns
+    value: # Optional
+  - name: idleCheckFrequency
+    value: # Optional
+  - name: idleTimeout
+    value: # Optional
+```
+
+{{% alert title="Warning" color="warning" %}}
+The above example uses secrets as plain strings. It is recommended to use a secret store for the secrets, as described [here]({{< ref component-secrets.md >}}).
+{{% /alert %}}
+
+
+## Spec metadata fields
+
+| Field              | Required | Details | Example |
+|--------------------|:--------:|---------|---------|
+| redisHost          | Y        | Connection-string for the redis host  | `localhost:6379`, `redis-master.default.svc.cluster.local:6379`
+| redisPassword      | Y        | Password for Redis host. No Default. Can be `secretKeyRef` to use a secret reference  | `""`, `"KeFg23!"`
+| redisUsername      | N        | Username for Redis host. Defaults to empty. Make sure your redis server version is 6 or above, and have created acl rule correctly. | `""`, `"default"`
+| enableTLS          | N         | If the Redis instance supports TLS with public certificates, can be configured to be enabled or disabled. Defaults to `"false"` | `"true"`, `"false"`
+| maxRetries         | N         | Maximum number of retries before giving up. Defaults to `3` | `5`, `10`
+| maxRetryBackoff    | N         | Minimum backoff between each retry. Defaults to `2` seconds; `"-1"` disables backoff. | `3000000000`
+| failover           | N         | Property to enabled failover configuration. Needs sentinalMasterName to be set. The redisHost should be the sentinel host address. See [Redis Sentinel Documentation](https://redis.io/docs/manual/sentinel/). Defaults to `"false"` | `"true"`, `"false"`
+| sentinelMasterName | N         | The sentinel master name. See [Redis Sentinel Documentation](https://redis.io/docs/manual/sentinel/) | `""`,  `"127.0.0.1:6379"`
+| redeliverInterval  | N        | The interval between checking for pending messages to redelivery. Defaults to `"60s"`. `"0"` disables redelivery. | `"30s"`
+| processingTimeout  | N        | The amount time a message must be pending before attempting to redeliver it. Defaults to `"15s"`. `"0"` disables redelivery. | `"30s"`
+| redisType          | N        | The type of redis. There are two valid values, one is `"node"` for single node mode, the other is `"cluster"` for redis cluster mode. Defaults to `"node"`. | `"cluster"`
+| redisDB            | N        | Database selected after connecting to redis. If `"redisType"` is `"cluster"` this option is ignored. Defaults to `"0"`. | `"0"`
+| redisMaxRetries    | N        | Alias for `maxRetries`. If both values are set `maxRetries` is ignored. | `"5"`
+| redisMinRetryInterval        | N        | Minimum backoff for redis commands between each retry. Default is `"8ms"`;  `"-1"` disables backoff. | `"8ms"`
+| redisMaxRetryInterval        | N        | Alias for `maxRetryBackoff`. If both values are set `maxRetryBackoff` is ignored.  | `"5s"`
+| dialTimeout        | N        | Dial timeout for establishing new connections. Defaults to `"5s"`.  | `"5s"`
+| readTimeout        | N        | Timeout for socket reads. If reached, redis commands will fail with a timeout instead of blocking. Defaults to `"3s"`, `"-1"` for no timeout. | `"3s"`
+| writeTimeout       | N        | Timeout for socket writes. If reached, redis commands will fail with a timeout instead of blocking. Defaults is readTimeout. | `"3s"`
+| poolSize           | N        | Maximum number of socket connections. Default is 10 connections per every CPU as reported by runtime.NumCPU. | `"20"`
+| poolTimeout        | N        | Amount of time client waits for a connection if all connections are busy before returning an error. Default is readTimeout + 1 second. | `"5s"`
+| maxConnAge         | N        | Connection age at which the client retires (closes) the connection. Default is to not close aged connections. | `"30m"`
+| minIdleConns       | N        | Minimum number of idle connections to keep open in order to avoid the performance degradation associated with creating new connections. Defaults to `"0"`. | `"2"`
+| idleCheckFrequency | N        | Frequency of idle checks made by idle connections reaper. Default is `"1m"`. `"-1"` disables idle connections reaper. | `"-1"`
+| idleTimeout        | N        | Amount of time after which the client closes idle connections. Should be less than server's timeout. Default is `"5m"`. `"-1"` disables idle timeout check. | `"10m"`
+
+## Setup Redis
+
+Dapr can use any Redis instance: containerized, running on your local dev machine, or a managed cloud service.
+
+{{< tabs "Self-Hosted" "Kubernetes" "Azure" "AWS" "GCP" >}}
+
+{{% codetab %}}
+A Redis instance is automatically created as a Docker container when you run `dapr init`
+{{% /codetab %}}
+
+{{% codetab %}}
+You can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Kubernetes cluster. This approach requires [Installing Helm](https://github.com/helm/helm#install).
+
+1. Install Redis into your cluster. Note that we're explicitly setting an image tag to get a version greater than 5, which is what Dapr' pub/sub functionality requires. If you're intending on using Redis as just a state store (and not for pub/sub), you do not have to set the image version.
+    ```bash
+    helm repo add bitnami https://charts.bitnami.com/bitnami
+    helm install redis bitnami/redis
+    ```
+
+2. Run `kubectl get pods` to see the Redis containers now running in your cluster.
+3. Add `redis-master:6379` as the `redisHost` in your [redis.yaml](#configuration) file. For example:
+    ```yaml
+        metadata:
+        - name: redisHost
+          value: redis-master:6379
+    ```
+4. Next, get the Redis password, which is slightly different depending on the OS we're using:
+    - **Windows**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" > encoded.b64`, which creates a file with your encoded password. Next, run `certutil -decode encoded.b64 password.txt`, which will put your redis password in a text file called `password.txt`. Copy the password and delete the two files.
+
+    - **Linux/MacOS**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" | base64 --decode` and copy the outputted password.
+
+    Add this password as the `redisPassword` value in your [redis.yaml](#configuration) file. For example:
+    ```yaml
+        metadata:
+        - name: redisPassword
+          value: lhDOkwTlp0
+    ```
+{{% /codetab %}}
+
+{{% codetab %}}
+**Note**: this approach requires having an Azure Subscription.
+
+1. [Start the Azure Cache for Redis creation flow](https://ms.portal.azure.com/#create/Microsoft.Cache). Log in if necessary.
+2. Fill out necessary information and **check the "Unblock port 6379" box**, which will allow us to persist state without SSL.
+3. Click "Create" to kickoff deployment of your Redis instance.
+4. Once your instance is created, you'll need to grab the Host name (FQDN) and your access key:
+   - For the Host name: navigate to the resource's "Overview" and copy "Host name".
+   - For your access key: navigate to "Settings" > "Access Keys" to copy and save your key.
+5. Add your key and your host to a `redis.yaml` file that Dapr can apply to your cluster. 
+   - If you're running a sample, add the host and key to the provided `redis.yaml`. 
+   - If you're creating a project from the ground up, create a `redis.yaml` file as specified in [Configuration](#configuration). 
+   
+   Set the `redisHost` key to `[HOST NAME FROM PREVIOUS STEP]:6379` and the `redisPassword` key to the key you saved earlier. 
+   
+   **Note:** In a production-grade application, follow [secret management]({{< ref component-secrets.md >}}) instructions to securely manage your secrets.
+
+> **NOTE:** Dapr pub/sub uses [Redis Streams](https://redis.io/topics/streams-intro) that was introduced by Redis 5.0, which isn't currently available on Azure Managed Redis Cache. Consequently, you can use Azure Managed Redis Cache only for state persistence.
+{{% /codetab %}}
+
+{{% codetab %}}
+[AWS Redis](https://aws.amazon.com/redis/)
+{{% /codetab %}}
+
+{{% codetab %}}
+[GCP Cloud MemoryStore](https://cloud.google.com/memorystore/)
+{{% /codetab %}}
+
+{{< /tabs >}}
+
+
+## Related links
+- [Basic schema for a Dapr component]({{< ref component-schema >}})
+- [Distributed lock building block]({{< ref distributed-lock-api-overview >}})

daprdocs/content/en/reference/components-reference/supported-state-stores/setup-redis.md

@@ -35,6 +35,42 @@ spec:
     value: # Optional
   - name: maxRetryBackoff
     value: # Optional
+    - name: failover
+    value: # Optional
+  - name: sentinelMasterName
+    value: # Optional
+  - name: redeliverInterval
+    value: # Optional
+  - name: processingTimeout
+    value: # Optional
+  - name: redisType
+    value: # Optional
+  - name: redisDB
+    value: # Optional
+  - name: redisMaxRetries
+    value: # Optional
+  - name: redisMinRetryInterval
+    value: # Optional
+  - name: redisMaxRetryInterval
+    value: # Optional
+  - name: dialTimeout
+    value: # Optional
+  - name: readTimeout
+    value: # Optional
+  - name: writeTimeout
+    value: # Optional
+  - name: poolSize
+    value: # Optional
+  - name: poolTimeout
+    value: # Optional
+  - name: maxConnAge
+    value: # Optional
+  - name: minIdleConns
+    value: # Optional
+  - name: idleCheckFrequency
+    value: # Optional
+  - name: idleTimeout
+    value: # Optional
   - name: ttlInSeconds
     value: <int> # Optional
   - name: queryIndexes
@@ -60,7 +96,6 @@ If you wish to use Redis as an actor store, append the following to the yaml.
 | redisHost          | Y        | Connection-string for the redis host  | `localhost:6379`, `redis-master.default.svc.cluster.local:6379`
 | redisPassword      | Y        | Password for Redis host. No Default. Can be `secretKeyRef` to use a secret reference  | `""`, `"KeFg23!"`
 | redisUsername      | N        | Username for Redis host. Defaults to empty. Make sure your redis server version is 6 or above, and have created acl rule correctly. | `""`, `"default"`
-| consumerID         | N         | The consumer group ID   | `"myGroup"`
 | enableTLS          | N         | If the Redis instance supports TLS with public certificates, can be configured to be enabled or disabled. Defaults to `"false"` | `"true"`, `"false"`
 | maxRetries         | N         | Maximum number of retries before giving up. Defaults to `3` | `5`, `10`
 | maxRetryBackoff    | N         | Minimum backoff between each retry. Defaults to `2` seconds; `"-1"` disables backoff. | `3000000000`
@@ -68,18 +103,18 @@ If you wish to use Redis as an actor store, append the following to the yaml.
 | sentinelMasterName | N         | The sentinel master name. See [Redis Sentinel Documentation](https://redis.io/docs/manual/sentinel/) | `""`,  `"127.0.0.1:6379"`
 | redeliverInterval  | N        | The interval between checking for pending messages to redelivery. Defaults to `"60s"`. `"0"` disables redelivery. | `"30s"`
 | processingTimeout  | N        | The amount time a message must be pending before attempting to redeliver it. Defaults to `"15s"`. `"0"` disables redelivery. | `"30s"`
-| redisType        | N        | The type of redis. There are two valid values, one is `"node"` for single node mode, the other is `"cluster"` for redis cluster mode. Defaults to `"node"`. | `"cluster"`
-| redisDB        | N        | Database selected after connecting to redis. If `"redisType"` is `"cluster"` this option is ignored. Defaults to `"0"`. | `"0"`
-| redisMaxRetries        | N        | Alias for `maxRetries`. If both values are set `maxRetries` is ignored. | `"5"`
+| redisType          | N        | The type of redis. There are two valid values, one is `"node"` for single node mode, the other is `"cluster"` for redis cluster mode. Defaults to `"node"`. | `"cluster"`
+| redisDB            | N        | Database selected after connecting to redis. If `"redisType"` is `"cluster"` this option is ignored. Defaults to `"0"`. | `"0"`
+| redisMaxRetries    | N        | Alias for `maxRetries`. If both values are set `maxRetries` is ignored. | `"5"`
 | redisMinRetryInterval        | N        | Minimum backoff for redis commands between each retry. Default is `"8ms"`;  `"-1"` disables backoff. | `"8ms"`
 | redisMaxRetryInterval        | N        | Alias for `maxRetryBackoff`. If both values are set `maxRetryBackoff` is ignored.  | `"5s"`
 | dialTimeout        | N        | Dial timeout for establishing new connections. Defaults to `"5s"`.  | `"5s"`
 | readTimeout        | N        | Timeout for socket reads. If reached, redis commands will fail with a timeout instead of blocking. Defaults to `"3s"`, `"-1"` for no timeout. | `"3s"`
-| writeTimeout        | N        | Timeout for socket writes. If reached, redis commands will fail with a timeout instead of blocking. Defaults is readTimeout. | `"3s"`
-| poolSize        | N        | Maximum number of socket connections. Default is 10 connections per every CPU as reported by runtime.NumCPU. | `"20"`
+| writeTimeout       | N        | Timeout for socket writes. If reached, redis commands will fail with a timeout instead of blocking. Defaults is readTimeout. | `"3s"`
+| poolSize           | N        | Maximum number of socket connections. Default is 10 connections per every CPU as reported by runtime.NumCPU. | `"20"`
 | poolTimeout        | N        | Amount of time client waits for a connection if all connections are busy before returning an error. Default is readTimeout + 1 second. | `"5s"`
-| maxConnAge        | N        | Connection age at which the client retires (closes) the connection. Default is to not close aged connections. | `"30m"`
-| minIdleConns        | N        | Minimum number of idle connections to keep open in order to avoid the performance degradation associated with creating new connections. Defaults to `"0"`. | `"2"`
+| maxConnAge         | N        | Connection age at which the client retires (closes) the connection. Default is to not close aged connections. | `"30m"`
+| minIdleConns       | N        | Minimum number of idle connections to keep open in order to avoid the performance degradation associated with creating new connections. Defaults to `"0"`. | `"2"`
 | idleCheckFrequency        | N        | Frequency of idle checks made by idle connections reaper. Default is `"1m"`. `"-1"` disables idle connections reaper. | `"-1"`
 | idleTimeout        | N        | Amount of time after which the client closes idle connections. Should be less than server's timeout. Default is `"5m"`. `"-1"` disables idle timeout check. | `"10m"`
 | actorStateStore    | N         | Consider this state store for actors. Defaults to `"false"` | `"true"`, `"false"`
@@ -88,17 +123,16 @@ If you wish to use Redis as an actor store, append the following to the yaml.
 
 ## Setup Redis
 
-Dapr can use any Redis instance - containerized, running on your local dev machine, or a managed cloud service. 
+Dapr can use any Redis instance: containerized, running on your local dev machine, or a managed cloud service.
 
 {{< tabs "Self-Hosted" "Kubernetes" "Azure" "AWS" "GCP" >}}
 
 {{% codetab %}}
 A Redis instance is automatically created as a Docker container when you run `dapr init`
-
 {{% /codetab %}}
 
 {{% codetab %}}
-We can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Kubernetes cluster. This approach requires [Installing Helm](https://github.com/helm/helm#install).
+You can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Kubernetes cluster. This approach requires [Installing Helm](https://github.com/helm/helm#install).
 
 1. Install Redis into your cluster. Note that we're explicitly setting an image tag to get a version greater than 5, which is what Dapr' pub/sub functionality requires. If you're intending on using Redis as just a state store (and not for pub/sub), you do not have to set the image version.
     ```bash
@@ -113,8 +147,8 @@ We can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Ku
         - name: redisHost
           value: redis-master:6379
     ```
-4. Next, we'll get the Redis password, which is slightly different depending on the OS we're using:
-    - **Windows**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" > encoded.b64`, which will create a file with your encoded password. Next, run `certutil -decode encoded.b64 password.txt`, which will put your redis password in a text file called `password.txt`. Copy the password and delete the two files.
+4. Next, get the Redis password, which is slightly different depending on the OS we're using:
+    - **Windows**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" > encoded.b64`, which creates a file with your encoded password. Next, run `certutil -decode encoded.b64 password.txt`, which will put your redis password in a text file called `password.txt`. Copy the password and delete the two files.
 
     - **Linux/MacOS**: Run `kubectl get secret --namespace default redis -o jsonpath="{.data.redis-password}" | base64 --decode` and copy the outputted password.
 
@@ -129,13 +163,19 @@ We can use [Helm](https://helm.sh/) to quickly create a Redis instance in our Ku
 {{% codetab %}}
 **Note**: this approach requires having an Azure Subscription.
 
-1. Open [this link](https://ms.portal.azure.com/#create/Microsoft.Cache) to start the Azure Cache for Redis  creation flow. Log in if necessary.
+1. [Start the Azure Cache for Redis creation flow](https://ms.portal.azure.com/#create/Microsoft.Cache). Log in if necessary.
 2. Fill out necessary information and **check the "Unblock port 6379" box**, which will allow us to persist state without SSL.
 3. Click "Create" to kickoff deployment of your Redis instance.
-4. Once your instance is created, you'll need to grab the Host name (FQDN) and your access key.
-   - for the Host name navigate to the resources "Overview" and copy "Host name"
-   - for your access key navigate to "Access Keys" under "Settings" and copy your key.
-5. Finally, we need to add our key and our host to a `redis.yaml` file that Dapr can apply to our cluster. If you're running a sample, you'll add the host and key to the provided `redis.yaml`. If you're creating a project from the ground up, you'll create a `redis.yaml` file as specified in [Configuration](#configuration). Set the `redisHost` key to `[HOST NAME FROM PREVIOUS STEP]:6379` and the `redisPassword` key to the key you copied in step 4. **Note:** In a production-grade application, follow [secret management]({{< ref component-secrets.md >}}) instructions to securely manage your secrets.
+4. Once your instance is created, you'll need to grab the Host name (FQDN) and your access key:
+   - For the Host name: navigate to the resource's "Overview" and copy "Host name".
+   - For your access key: navigate to "Settings" > "Access Keys" to copy and save your key.
+5. Add your key and your host to a `redis.yaml` file that Dapr can apply to your cluster. 
+   - If you're running a sample, add the host and key to the provided `redis.yaml`. 
+   - If you're creating a project from the ground up, create a `redis.yaml` file as specified in [Configuration](#configuration). 
+   
+   Set the `redisHost` key to `[HOST NAME FROM PREVIOUS STEP]:6379` and the `redisPassword` key to the key you saved earlier. 
+   
+   **Note:** In a production-grade application, follow [secret management]({{< ref component-secrets.md >}}) instructions to securely manage your secrets.
 
 > **NOTE:** Dapr pub/sub uses [Redis Streams](https://redis.io/topics/streams-intro) that was introduced by Redis 5.0, which isn't currently available on Azure Managed Redis Cache. Consequently, you can use Azure Managed Redis Cache only for state persistence.
 {{% /codetab %}}

daprdocs/data/components/locks/generic.yaml

@@ -0,0 +1,5 @@
+- component: Redis
+  link: redis-lock
+  state: Alpha
+  version: v1
+  since: "1.8"

daprdocs/layouts/partials/components/locks.html

@@ -0,0 +1,27 @@
+{{- $groups := dict
+" Generic" $.Site.Data.components.locks.generic
+}}
+
+{{ range $group, $components := $groups }}
+<h3>{{ $group }}</h3>
+<table width="100%">
+    <tr>
+        <th>Component</th>
+        <th>Status</th>
+        <th>Component version</th>
+        <th>Since runtime version</th>
+    </tr>
+    {{ range sort $components "component" }}
+    <tr>
+        <td><a href="/reference/components-reference/supported-locks/{{ .link }}/" }}>{{ .component
+                }}</a>
+        </td>
+        <td>{{ .state }}</td>
+        <td>{{ .version }}</td>
+        <td>{{ .since }}</td>
+    </tr>
+    {{ end }}
+</table>
+{{ end }}
+
+{{ partial "components/componenttoc.html" . }}