Add FailRandomlyAtFault command to Fault Injection cluster (#22008)

* Add FailRandomlyAtFault command to Fault Injection cluster

* Run codegen

* Address review comments

examples/all-clusters-app/all-clusters-common/all-clusters-app.matter

@@ -3850,7 +3850,14 @@ server cluster FaultInjection = 4294048774 {
     BOOLEAN takeMutex = 4;
   }
 
+  request struct FailRandomlyAtFaultRequest {
+    FaultType type = 0;
+    INT32U id = 1;
+    INT8U percentage = 2;
+  }
+
   command access(invoke: manage) FailAtFault(FailAtFaultRequest): DefaultSuccess = 0;
+  command access(invoke: manage) FailRandomlyAtFault(FailRandomlyAtFaultRequest): DefaultSuccess = 1;
 }
 
 endpoint 0 {

examples/all-clusters-app/all-clusters-common/all-clusters-app.zap

@@ -8461,6 +8461,14 @@
               "source": "client",
               "incoming": 1,
               "outgoing": 1
+            },
+            {
+              "name": "FailRandomlyAtFault",
+              "code": 1,
+              "mfgCode": null,
+              "source": "client",
+              "incoming": 1,
+              "outgoing": 0
             }
           ],
           "attributes": [

src/app/clusters/fault-injection-server/fault-injection-server.cpp

@@ -36,21 +36,14 @@ using namespace chip::app;
 using namespace chip::app::Clusters::FaultInjection;
 using chip::Protocols::InteractionModel::Status;
 
-bool emberAfFaultInjectionClusterFailAtFaultCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
-                                                     const Commands::FailAtFault::DecodableType & commandData)
-{
-    if (commandPath.mClusterId != Clusters::FaultInjection::Id)
-    {
-        // We shouldn't have been called at all.
-        commandObj->AddStatus(commandPath, Status::UnsupportedCluster);
-        return true;
-    }
+namespace {
 
 #if CHIP_WITH_NLFAULTINJECTION
-    Status returnStatus                             = Status::Success;
+nl::FaultInjection::Manager * GetFaultInjectionManager(FaultType type)
+{
     nl::FaultInjection::Manager * faultInjectionMgr = nullptr;
 
-    switch (commandData.type)
+    switch (type)
     {
     case FaultType::kSystemFault:
         faultInjectionMgr = &chip::System::FaultInjection::GetManager();
@@ -62,11 +55,29 @@ bool emberAfFaultInjectionClusterFailAtFaultCallback(CommandHandler * commandObj
         faultInjectionMgr = &chip::FaultInjection::GetManager();
         break;
     default:
-        ChipLogError(Zcl, "FaultInjection: Unsupported Fault type received");
-        returnStatus = Status::InvalidCommand;
         break;
     }
 
+    return faultInjectionMgr;
+}
+#endif
+
+} // anonymous namespace
+
+bool emberAfFaultInjectionClusterFailAtFaultCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
+                                                     const Commands::FailAtFault::DecodableType & commandData)
+{
+    if (commandPath.mClusterId != Clusters::FaultInjection::Id)
+    {
+        // We shouldn't have been called at all.
+        commandObj->AddStatus(commandPath, Status::UnsupportedCluster);
+        return true;
+    }
+
+#if CHIP_WITH_NLFAULTINJECTION
+    Status returnStatus                             = Status::Success;
+    nl::FaultInjection::Manager * faultInjectionMgr = GetFaultInjectionManager(commandData.type);
+
     if (faultInjectionMgr != nullptr)
     {
         ChipLogProgress(Zcl, "FaultInjection: Configure a fault of type: %d and Id: %d to be triggered deterministically",
@@ -93,4 +104,49 @@ bool emberAfFaultInjectionClusterFailAtFaultCallback(CommandHandler * commandObj
     return true;
 }
 
+bool emberAfFaultInjectionClusterFailRandomlyAtFaultCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath,
+                                                             const Commands::FailRandomlyAtFault::DecodableType & commandData)
+{
+    if (commandPath.mClusterId != Clusters::FaultInjection::Id)
+    {
+        // We shouldn't have been called at all.
+        commandObj->AddStatus(commandPath, Status::UnsupportedCluster);
+        return true;
+    }
+
+    if (commandData.percentage > 100)
+    {
+        commandObj->AddStatus(commandPath, Status::InvalidCommand);
+        return true;
+    }
+
+#if CHIP_WITH_NLFAULTINJECTION
+    Status returnStatus                             = Status::Success;
+    nl::FaultInjection::Manager * faultInjectionMgr = GetFaultInjectionManager(commandData.type);
+
+    if (faultInjectionMgr != nullptr)
+    {
+        ChipLogProgress(Zcl, "FaultInjection: Configure a fault of type: %d and Id: %d to be triggered randomly",
+                        static_cast<uint8_t>(commandData.type), commandData.id);
+        int32_t err = faultInjectionMgr->FailRandomlyAtFault(commandData.id, commandData.percentage);
+
+        if (err != 0)
+        {
+            ChipLogError(Zcl, "FaultInjection: Pass invalid inputs to FailAtFault");
+            returnStatus = Status::InvalidCommand;
+        }
+    }
+    else
+    {
+        ChipLogError(Zcl, "FaultInjection: Failed to get Fault Injection manager");
+        returnStatus = Status::Failure;
+    }
+#else
+    Status returnStatus = Status::UnsupportedCommand;
+#endif // CHIP_WITH_NLFAULTINJECTION
+
+    commandObj->AddStatus(commandPath, returnStatus);
+    return true;
+}
+
 void MatterFaultInjectionPluginServerInitCallback() {}

src/app/zap-templates/zcl/data-model/chip/fault-injection-cluster.xml

@@ -39,5 +39,12 @@ limitations under the License.
       <arg name="TakeMutex" type="BOOLEAN"/>      
       <access op="invoke" role="manage"/>
     </command>
+    <command source="client" code="0x01" name="FailRandomlyAtFault" optional="false">
+      <description>Configure a fault to be triggered randomly, with a given probability defined as a percentage</description>
+      <arg name="Type" type="FaultType"/>      
+      <arg name="Id" type="INT32U"/>
+      <arg name="Percentage" type="INT8U"/>   
+      <access op="invoke" role="manage"/>
+    </command>    
   </cluster>
 </configurator>