Add support for an attribute check whether it's being done over large payload-supporting transport (project-chip#40141)

* Add support for an attribute read to check whether it's being done over a transport that supports large message payload

* Review suggestions

---------

Co-authored-by: Andrei Litvin <[email protected]>

Author: gmarcosb

src/app/AttributeAccessInterface.h

@@ -21,6 +21,7 @@
 #include <app/AttributeReportBuilder.h>
 #include <app/AttributeValueDecoder.h>
 #include <app/AttributeValueEncoder.h>
+#include <app/data-model-provider/OperationTypes.h>
 #include <lib/core/CHIPError.h>
 
 /**
@@ -51,7 +52,7 @@ class AttributeAccessInterface
     /**
      * Callback for reading attributes.
      *
-     * @param [in] aPath indicates which exact data is being read.
+     * @param [in] aRequest indicates which exact data is being read along with attributes of how data is being read.
      * @param [in] aEncoder the AttributeValueEncoder to use for encoding the
      *             data.
      *
@@ -66,6 +67,17 @@ class AttributeAccessInterface
      *    involve reading from the attribute store or external attribute
      *    callbacks.
      */
+    virtual CHIP_ERROR Read(const DataModel::ReadAttributeRequest & aRequest, AttributeValueEncoder & aEncoder)
+    {
+        return Read(aRequest.path, aEncoder);
+    }
+
+    /**
+     * A simpler version of Read(const ReadAttributeRequest & request, AttributeValueEncoder & aEncoder)
+     * which takes simply the path being read, for backwards compatibility.
+     *
+     * @param [in] aPath indicates which exact data is being read.
+     */
     virtual CHIP_ERROR Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) = 0;
 
     /**

src/app/BUILD.gn

@@ -314,6 +314,7 @@ static_library("attribute-access") {
     "${chip_root}/src/access:types",
     "${chip_root}/src/app/MessageDef",
     "${chip_root}/src/app/data-model",
+    "${chip_root}/src/app/data-model-provider:core",
     "${chip_root}/src/app/util:af-types",
     "${chip_root}/src/lib/core",
     "${chip_root}/src/lib/support",

src/app/ReadHandler.h

@@ -432,6 +432,7 @@ class ReadHandler : public Messaging::ExchangeDelegate
 
     Transport::SecureSession * GetSession() const;
     SubjectDescriptor GetSubjectDescriptor() const { return GetSession()->GetSubjectDescriptor(); }
+    bool AllowsLargePayload() const { return GetSession()->AllowsLargePayload(); }
 
     auto GetTransactionStartGeneration() const { return mTransactionStartGeneration; }
 

src/app/data-model-provider/BUILD.gn

@@ -24,6 +24,16 @@ source_set("metadata") {
   ]
 }
 
+source_set("core") {
+  public = [ "OperationTypes.h" ]
+
+  public_deps = [
+    "${chip_root}/src/access:types",
+    "${chip_root}/src/app:paths",
+    "${chip_root}/src/app/data-model",
+  ]
+}
+
 source_set("data-model-provider") {
   sources = [
     "ActionContext.h",
@@ -33,14 +43,14 @@ source_set("data-model-provider") {
     "EventsGenerator.h",
     "MetadataLookup.cpp",
     "MetadataLookup.h",
-    "OperationTypes.h",
     "Provider.h",
     "ProviderChangeListener.h",
     "ProviderMetadataTree.cpp",
     "ProviderMetadataTree.h",
   ]
 
   public_deps = [
+    ":core",
     ":metadata",
     "${chip_root}/src/app:attribute-access",
     "${chip_root}/src/app:command-handler",

src/app/data-model-provider/OperationTypes.h

@@ -70,7 +70,8 @@ struct OperationRequest
 
 enum class ReadFlags : uint32_t
 {
-    kFabricFiltered = 0x0001, // reading is performed fabric-filtered
+    kFabricFiltered     = 0x0001, // reading is performed fabric-filtered
+    kAllowsLargePayload = 0x0002, // reading is performed over a transport supporting large payload
 };
 
 enum class ListWriteOperation : uint8_t

src/app/reporting/Engine.cpp

@@ -50,6 +50,7 @@ namespace app {
 namespace reporting {
 namespace {
 
+using DataModel::ReadFlags;
 using Protocols::InteractionModel::Status;
 
 /// Returns the status of ACL validation.
@@ -148,7 +149,7 @@ std::optional<Status> ValidateAttributeIsReadable(DataModel::Provider * dataMode
 }
 
 DataModel::ActionReturnStatus RetrieveClusterData(DataModel::Provider * dataModel, const SubjectDescriptor & subjectDescriptor,
-                                                  bool isFabricFiltered, AttributeReportIBs::Builder & reportBuilder,
+                                                  BitFlags<ReadFlags> flags, AttributeReportIBs::Builder & reportBuilder,
                                                   const ConcreteReadAttributePath & path, AttributeEncodeState * encoderState)
 {
     ChipLogDetail(DataManagement, "<RE:Run> Cluster %" PRIx32 ", Attribute %" PRIx32 " is dirty", path.mClusterId,
@@ -158,7 +159,7 @@ DataModel::ActionReturnStatus RetrieveClusterData(DataModel::Provider * dataMode
 
     DataModel::ReadAttributeRequest readRequest;
 
-    readRequest.readFlags.Set(DataModel::ReadFlags::kFabricFiltered, isFabricFiltered);
+    readRequest.readFlags         = flags;
     readRequest.subjectDescriptor = &subjectDescriptor;
     readRequest.path              = path;
 
@@ -178,6 +179,7 @@ DataModel::ActionReturnStatus RetrieveClusterData(DataModel::Provider * dataMode
     reportBuilder.Checkpoint(checkpoint);
 
     DataModel::ActionReturnStatus status(CHIP_NO_ERROR);
+    bool isFabricFiltered = flags.Has(ReadFlags::kFabricFiltered);
     AttributeValueEncoder attributeValueEncoder(reportBuilder, subjectDescriptor, path, version, isFabricFiltered, encoderState);
 
     // TODO: we explicitly DO NOT validate that path is a valid cluster path (even more, above serverClusterFinder
@@ -472,9 +474,12 @@ CHIP_ERROR Engine::BuildSingleReportDataAttributeReportIBs(ReportDataMessage::Bu
             ConcreteReadAttributePath pathForRetrieval(readPath);
             // Load the saved state from previous encoding session for chunking of one single attribute (list chunking).
             AttributeEncodeState encodeState = apReadHandler->GetAttributeEncodeState();
+            BitFlags<ReadFlags> flags;
+            flags.Set(ReadFlags::kFabricFiltered, apReadHandler->IsFabricFiltered());
+            flags.Set(ReadFlags::kAllowsLargePayload, apReadHandler->AllowsLargePayload());
             DataModel::ActionReturnStatus status =
-                RetrieveClusterData(mpImEngine->GetDataModelProvider(), apReadHandler->GetSubjectDescriptor(),
-                                    apReadHandler->IsFabricFiltered(), attributeReportIBs, pathForRetrieval, &encodeState);
+                RetrieveClusterData(mpImEngine->GetDataModelProvider(), apReadHandler->GetSubjectDescriptor(), flags,
+                                    attributeReportIBs, pathForRetrieval, &encodeState);
             if (status.IsError())
             {
                 // Operation error set, since this will affect early return or override on status encoding

src/data-model-providers/codegen/CodegenDataModelProvider_Read.cpp

@@ -56,7 +56,7 @@ using Protocols::InteractionModel::Status;
 ///
 /// If it returns std::nullopt, then there is no AAI to handle the given path
 /// and processing should figure out the value otherwise (generally from other ember data)
-std::optional<CHIP_ERROR> TryReadViaAccessInterface(const ConcreteAttributePath & path, AttributeAccessInterface * aai,
+std::optional<CHIP_ERROR> TryReadViaAccessInterface(const DataModel::ReadAttributeRequest & request, AttributeAccessInterface * aai,
                                                     AttributeValueEncoder & encoder)
 {
     // Processing can happen only if an attribute access interface actually exists..
@@ -65,12 +65,12 @@ std::optional<CHIP_ERROR> TryReadViaAccessInterface(const ConcreteAttributePath
         return std::nullopt;
     }
 
-    CHIP_ERROR err = aai->Read(path, encoder);
+    CHIP_ERROR err = aai->Read(request, encoder);
 
     if (err != CHIP_NO_ERROR)
     {
         // Implementation of 8.4.3.2 of the spec for path expansion
-        if (path.mExpanded && (err == CHIP_IM_GLOBAL_STATUS(UnsupportedRead)))
+        if (request.path.mExpanded && (err == CHIP_IM_GLOBAL_STATUS(UnsupportedRead)))
         {
             return CHIP_NO_ERROR;
         }
@@ -115,7 +115,7 @@ DataModel::ActionReturnStatus CodegenDataModelProvider::ReadAttribute(const Data
 
     // Read via AAI
     std::optional<CHIP_ERROR> aai_result = TryReadViaAccessInterface(
-        request.path, AttributeAccessInterfaceRegistry::Instance().Get(request.path.mEndpointId, request.path.mClusterId), encoder);
+        request, AttributeAccessInterfaceRegistry::Instance().Get(request.path.mEndpointId, request.path.mClusterId), encoder);
     VerifyOrReturnError(!aai_result.has_value(), *aai_result);
 
     // At this point, we have to use ember directly to read the data.