Merge branch 'main' into release-rs-fuya-fuya-dec

Author: rrelledge

content/commands/json.arrtrim/index.md

@@ -88,7 +88,7 @@ Create two headphone products with maximum sound levels.
 
 {{< highlight bash >}}
 redis> JSON.SET key $
-"[[{\"name\":\"Healthy headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"max_level\":[60,70,80]},{\"name\":\"Noisy headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"max_level\":[85,90,100,120]}]]"
+"[{\"name\":\"Healthy headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"max_level\":[60,70,80]},{\"name\":\"Noisy headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"max_level\":[85,90,100,120]}]"
 OK
 {{< / highlight >}}
 

content/develop/clients/redis-py/transpipe.md

@@ -0,0 +1,169 @@
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use Redis pipelines and transactions
+linkTitle: Pipelines/transactions
+title: Pipelines and transactions
+weight: 2
+---
+
+Redis lets you send a sequence of commands to the server together in a batch.
+There are two types of batch that you can use:
+
+-   **Pipelines** avoid network and processing overhead by sending several commands
+    to the server together in a single communication. The server then sends back
+    a single communication with all the responses. See the
+    [Pipelining]({{< relref "/develop/use/pipelining" >}}) page for more
+    information.
+-   **Transactions** guarantee that all the included commands will execute
+    to completion without being interrupted by commands from other clients.
+    See the [Transactions]({{< relref "/develop/interact/transactions" >}})
+    page for more information.
+
+## Execute a pipeline
+
+To execute commands in a pipeline, you first create a pipeline object
+and then add commands to it using methods that resemble the standard
+command methods (for example, `set()` and `get()`). The commands are
+buffered in the pipeline and only execute when you call the `execute()`
+method on the pipeline object. This method returns a list that contains
+the results from all the commands in order.
+
+Note that the command methods for a pipeline always return the original
+pipeline object, so you can "chain" several commands together, as the
+example below shows:
+
+<!-- Tested examples will replace the inline ones when they are approved.
+Markup removed to stop warnings.
+
+clients-example pipe_trans_tutorial basic_pipe Python
+/clients-example
+-->
+```python
+import redis
+
+r = redis.Redis(decode_responses=True)
+
+pipe = r.pipeline()
+
+for i in range(5):
+    pipe.set(f"seat:{i}", f"#{i}")
+
+set_5_result = pipe.execute()
+print(set_5_result)  # >>> [True, True, True, True, True]
+
+pipe = r.pipeline()
+
+# "Chain" pipeline commands together.
+get_3_result = pipe.get("seat:0").get("seat:3").get("seat:4").execute()
+print(get_3_result)  # >>> ['#0', '#3', '#4']
+```
+
+## Execute a transaction
+
+A pipeline actually executes as a transaction by default (that is to say,
+all commands are executed in an uninterrupted sequence). However, if you
+need to switch this behavior off, you can set the `transaction` parameter
+to `False` when you create the pipeline:
+
+```python
+pipe = r.pipeline(transaction=False)
+```
+
+## Watch keys for changes
+
+Redis supports *optimistic locking* to avoid inconsistent updates
+to different keys. The basic idea is to watch for changes to any
+keys that you use in a transaction while you are are processing the
+updates. If the watched keys do change, you must restart the updates
+with the latest data from the keys. See
+[Transactions]({{< relref "/develop/interact/transactions" >}})
+for more information about optimistic locking.
+
+The example below shows how to repeatedly attempt a transaction with a watched
+key until it succeeds. The code reads a string
+that represents a `PATH` variable for a command shell, then appends a new
+command path to the string before attempting to write it back. If the watched
+key is modified by another client before writing, the transaction aborts
+with a `WatchError` exception, and the loop executes again for another attempt.
+Otherwise, the loop terminates successfully.
+
+<!--
+clients-example pipe_trans_tutorial trans_watch Python
+/clients-example
+-->
+```python
+r.set("shellpath", "/usr/syscmds/")
+
+with r.pipeline() as pipe:
+    # Repeat until successful.
+    while True:
+        try:
+            # Watch the key we are about to change.
+            pipe.watch("shellpath")
+
+            # The pipeline executes commands directly (instead of
+            # buffering them) from immediately after the `watch()`
+            # call until we begin the transaction.
+            current_path = pipe.get("shellpath")
+            new_path = current_path + ":/usr/mycmds/"
+
+            # Start the transaction, which will enable buffering
+            # again for the remaining commands.
+            pipe.multi()
+
+            pipe.set("shellpath", new_path)
+
+            pipe.execute()
+
+            # The transaction succeeded, so break out of the loop.
+            break
+        except redis.WatchError:
+            # The transaction failed, so continue with the next attempt.
+            continue
+
+get_path_result = r.get("shellpath")
+print(get_path_result)  # >>> '/usr/syscmds/:/usr/mycmds/'
+```
+
+Because this is a common pattern, the library includes a convenience
+method called `transaction()` that handles the code to watch keys,
+execute the transaction, and retry if necessary. Pass
+`transaction()` a function that implements your main transaction code,
+and also pass the keys you want to watch. The example below implements
+the same basic transaction as the previous example but this time
+using `transaction()`. Note that `transaction()` can't add the `multi()`
+call automatically, so you must still place this correctly in your
+transaction function.
+
+<!--
+clients-example pipe_trans_tutorial watch_conv_method Python 
+/clients-example 
+*-->
+```python
+r.set("shellpath", "/usr/syscmds/")
+
+
+def watched_sequence(pipe):
+    current_path = pipe.get("shellpath")
+    new_path = current_path + ":/usr/mycmds/"
+
+    pipe.multi()
+
+    pipe.set("shellpath", new_path)
+
+
+trans_result = r.transaction(watched_sequence, "shellpath")
+print(trans_result)  # True
+
+get_path_result = r.get("shellpath")
+print(get_path_result)  # >>> '/usr/syscmds/:/usr/mycmds/'
+```

content/develop/interact/search-and-query/deprecated/development.md

@@ -174,8 +174,8 @@ You can open ```redis-cli``` in another terminal to interact with it.
 ## Running tests
 
 There are several sets of unit tests:
-* C tests, located in ```tests/ctests```, run by ```make c_tests```.
-* C++ tests (enabled by GTest), located in ```tests/cpptests```, run by ```make cpp_tests```.
+* C tests, located in ```tests/ctests```, run by ```make c-tests```.
+* C++ tests (enabled by GTest), located in ```tests/cpptests```, run by ```make cpp-tests```.
 * Python tests (enabled by RLTest), located in ```tests/pytests```, run by ```make pytest```.
 
 You can run all tests by invoking ```make test```.

content/develop/tools/insight/release-notes/v.2.62.0.md

@@ -0,0 +1,35 @@
+---
+Title: Redis Insight v2.62.0, November 2024
+linkTitle: v2.62.0 (November 2024)
+date: 2024-11-27 00:00:00 +0000
+description: Redis Insight v2.62
+weight: 1
+
+---
+## 2.62 (November 2024)
+This is the General Availability (GA) release of Redis Insight 2.62.
+
+### Highlights 
+- Support for multiple key name delimiters in Tree View, allowing more flexible browsing for databases with diverse key structures.
+- Remain authenticated to [Redis Copilot](https://redis.io/docs/latest/develop/tools/insight/?utm_source=redisinsight&utm_medium=main&utm_campaign=tutorials#:~:text=for%20more%20information.-,Redis%20Copilot,-Redis%20Copilot%20is), even after reopening Redis Insight, for seamless and uninterrupted access with daily use.
+
+### Details
+
+**Features and improvements**
+- [#4090](https://github.com/RedisInsight/RedisInsight/pull/4090) Added support for multiple key name delimiters in Tree View, enabling more flexible browsing of databases with varied key name patterns.
+- [#3957](https://github.com/RedisInsight/RedisInsight/pull/3957) Remain authenticated to [Redis Copilot](https://redis.io/docs/latest/develop/tools/insight/?utm_source=redisinsight&utm_medium=main&utm_campaign=tutorials#:~:text=for%20more%20information.-,Redis%20Copilot,-Redis%20Copilot%20is), even after reopening Redis Insight, for seamless and uninterrupted access with daily use.
+- [#3988](https://github.com/RedisInsight/RedisInsight/pull/3988), [#4059](https://github.com/RedisInsight/RedisInsight/pull/4059) Enhanced both the Java and PHP serialized formatters: the Java formatter now supports date and time data, while the PHP formatter includes UTF-8 encoding for better handling of special characters and multi-language data.
+- [#4081](https://github.com/RedisInsight/RedisInsight/pull/4081) Introduced a unique theme key name with a proxy path prefix to prevent conflicts when multiple instances run on the same origin.
+- [#2970](https://github.com/RedisInsight/RedisInsight/pull/4107) Upgraded to Electron 33.2.0 for enhanced security and compatibility with modern web standards.
+
+**Bugs**
+- [#4089](https://github.com/RedisInsight/RedisInsight/pull/4089) Resolved an issue where large integers in JSON keys were being rounded, ensuring data integrity.
+
+**SHA-256 Checksums**
+| Package | SHA-256 |
+|--|--|
+| Windows | ibZ5kn0GSdrbnfHRWC1lDdKozn6YllcGIrDhmLEnt2K1rjgjL2kGKvbtfq9QEkumgGwk2a9zTjr0u5zztGHriQ== |
+| Linux AppImage | bM6lbyeAHFX/f0sBehu9a9ifHsDvX8o/2qn91sdtyiRcIU+f31+Ch7K4NI4v226rgj6LvkFDWDNq6VQ4pyLAPA== |
+| Linux Debian| ilD86T/+8gEgrZg8MS8Niv/8g54FPeEn1nZrUI6DA7KTl3owqzqD0npb8fdAdL6YtSRbSBUK2fXPQ6GRXWZ/GA== |
+| MacOS Intel | pSy3CvRfVIT3O7BXUPMUoONRaZCOA1965tF9T19gZ1NnUn9YkjWlNXdniQHZ4ALKbpC2q62ygt39xF6O52LxAw== |
+| MacOS Apple silicon | uoz6I6MO4/j8UJo7eNje3dz4rx1KKj6mum/vXb2882fYPD/lK1cG0Q0OZu/lbxuk0xgzXfWv0MhMTIVVV+EADg== |

content/integrate/redis-data-integration/data-pipelines/data-pipelines.md

@@ -131,6 +131,11 @@ targets:
 #     cert: ${TARGET_DB_CERT}
 #     cacert: ${TARGET_DB_CACERT}
 #     key_password: ${TARGET_DB_KEY_PASSWORD}
+processors:
+# Enable Debezium LOB placeholders for tables that contain large objects.
+# Uncomment this property (and the `processors:` section) if your tables include
+# Oracle large objects (BLOB, CLOB, NCLOB).
+#  debezium_lob_encoded_placeholder: X19kZWJleml1bV91bmF2YWlsYWJsZV92YWx1ZQ==
 ```
 
 The main sections of the file configure [`sources`](#sources) and [`targets`](#targets).

content/integrate/redis-data-integration/data-pipelines/deploy.md

@@ -87,17 +87,24 @@ kubectl create secret generic source-db \
 --namespace=rdi \
 --from-literal=SOURCE_DB_PASSWORD=yourPassword
 
-# Source trust certificate
+# Source trust certificate (both commands are required)
+kubectl create secret generic source-db-ssl --from-file=ca.crt=/path/to/myca.crt -n rdi
+
 kubectl create secret generic source-db \
 --namespace=rdi \
 --from-literal=SOURCE_DB_CACERT=/etc/certificates/source_db/ca.crt
 
-# Source public key
+# Source public key (both commands are required)
+kubectl create secret generic source-db-ssl --from-file=client.crt=/path/to/myclient.crt -n rdi
+
 kubectl create secret generic source-db \
 --namespace=rdi \
 --from-literal=SOURCE_DB_CERT=/etc/certificates/source_db/client.crt
 
-# Source private key
+
+# Source private key (both commands are required)
+kubectl create secret generic source-db-ssl --from-file=client.key=/path/to/myclient.key -n rdi
+
 kubectl create secret generic source-db \
 --namespace=rdi \
 --from-literal=SOURCE_DB_KEY=/etc/certificates/source_db/client.key
@@ -116,20 +123,27 @@ kubectl create secret generic target-db \
 --namespace=rdi \
 --from-literal=TARGET_DB_PASSWORD=yourPassword
 
-# Target trust certificate
+# Target trust certificate (both commands are required)
+kubectl create secret generic target-db-ssl --from-file=ca.crt=/path/to/myca.crt -n rdi
+
 kubectl create secret generic target-db \
 --namespace=rdi \
 --from-literal=TARGET_DB_CACERT=/etc/certificates/target-db/ca.crt
 
-# Target public key
+# Target public key (both commands are required)
+kubectl create secret generic target-db-ssl --from-file=client.crt=/path/to/myclient.crt -n rdi
+
 kubectl create secret generic target-db \
 --namespace=rdi \
---from-literal=TARGET_DB_CERT=/etc/certificates/target-db/client.crt
+--from-literal=SOURCE_DB_CERT=/etc/certificates/target_db/client.crt
+
+
+# Target private key (both commands are required)
+kubectl create secret generic target-db-ssl --from-file=client.key=/path/to/myclient.key -n rdi
 
-# Target private key
 kubectl create secret generic target-db \
 --namespace=rdi \
---from-literal=TARGET_DB_KEY=/etc/certificates/target-db/client.key
+--from-literal=SOURCE_DB_KEY=/etc/certificates/target_db/client.key
 ```
 
 ## Deploy a pipeline

content/integrate/redis-data-integration/installation/install-k8s.md

@@ -61,6 +61,10 @@ information. *This requires Redis Enterprise v6.4 or greater*.
 - Use the Redis console to create a database with 250MB RAM with one primary and one replica.
 - If you are deploying RDI for a production environment then secure this database with a password
   and [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security).
+- Set the database's
+  [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}}) to `noeviction` and set
+  [data persistence]({{< relref "/operate/rs/databases/configure/database-persistence" >}})
+  to AOF - fsync every 1 sec.
 
 You should then provide the details of this database in the [`values.yaml`](#the-valuesyaml-file)
 file as described below.
@@ -465,6 +469,28 @@ collector-api-<id>                 1/1    Running       0        29m
 You can verify that the RDI API works by adding the server in
 [Redis Insight]({{< relref "/develop/tools/insight/rdi-connector" >}}).
 
+## Using ingress controllers
+
+If you want to expose the RDI API service via the K8s
+[`Ingress`](https://kubernetes.io/docs/concepts/services-networking/ingress/)
+resource, you must ensure that an appropriate
+[ingress controller](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/) is available in your K8s cluster. Follow the documentation of your cloud provider or of
+the ingress controller to install the controller correctly.
+
+### Using the `nginx` ingress controller on AKS
+
+On AKS, if you want to use the open source
+[`nginx`](https://nginx.org/)
+[ingress controller](https://github.com/kubernetes/ingress-nginx/blob/main/README.md#readme)
+rather than the
+[AKS application routing add-on](https://learn.microsoft.com/en-us/azure/aks/app-routing),
+follow the AKS documentation for
+[creating an unmanaged ingress controller](https://learn.microsoft.com/en-us/troubleshoot/azure/azure-kubernetes/load-bal-ingress-c/create-unmanaged-ingress-controller?tabs=azure-cli).
+Specifically, ensure that one or both of the following Helm chart values is set:
+
+- `controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz`
+- `controller.service.externalTrafficPolicy=Local`
+
 ## Prepare your source database
 
 You must also configure your source database to use the CDC connector. See the