Modify Execute command to return an error
authorChanggyu Choi <changyu.choi@samsung.com>
Sun, 27 Apr 2025 05:46:45 +0000 (14:46 +0900)
committerChanggyu Choi <changyu.choi@samsung.com>
Mon, 12 May 2025 05:11:17 +0000 (14:11 +0900)
Change to return an error if it fails because an error may occur when executing Execute.

Signed-off-by: Changgyu Choi <changyu.choi@samsung.com>
src/action/action_request_handler.cc
src/action/action_request_handler.hh
src/action/request_handler.hh
src/action/service.cc
tool/action_tool/tools/execute.cc

index 53e3b4e99da50e53086c6cca0dfb25680ded98ca..b5034453d034bc85717b5b30917d893268f980f3 100644 (file)
@@ -207,13 +207,13 @@ void ActionRequestHandler::OnGetActionId(const std::string& user_description,
                                          int top_k,
                                          float search_threshold) {}
 
-void ActionRequestHandler::OnExecute(const std::string& instance, pid_t pid,
+int ActionRequestHandler::OnExecute(const std::string& instance, pid_t pid,
                                      uid_t uid, rpc::ActionModel& action) {
   auto db = std::make_unique<action::SqliteDb>();
   std::string schema_json = db->GetAction(action.Getaction_id());
   if (!ActionValidator().CheckModelValid(schema_json, action.Getjson())) {
     LOG(DEBUG) << "OnExecute not valid : " << action.Getaction_id();
-    return;
+    return -1;
   }
 
   try {
@@ -227,15 +227,17 @@ void ActionRequestHandler::OnExecute(const std::string& instance, pid_t pid,
     auto required_privileges = db->GetRequiredPrivileges(model.GetId());
     if (!CheckPrivileges(pid, uid, required_privileges)) {
       LOG(ERROR) << "Not allowed to execute action due to missing privileges";
-      return;
+      return -1;
     }
 
     auto executor = ActionExecutorFactory::CreateExecutor(instance, model);
     executor->SetResultHandler(this);
-    executor->Execute(model);
+    int ret = executor->Execute(model);
     executors_.emplace_back(std::move(executor));
+    return ret;
   } catch (const std::runtime_error& e) {
     LOG(ERROR) << "Failed to execute action : " << e.what();
+    return -1;
   }
 }
 
index 8a2899989f7d528cc8481ee0028b9636e6198140..df6e25a2305008470113fca40fb9aeee887eab3e 100644 (file)
 #include "action/request_handler.hh"
 #include "action/tizen_action_service_stub.h"
 #include "common/action_executor.hh"
-#include "common/action_schema.h"
 #include "common/action_result_handler.hh"
+#include "common/action_schema.h"
 
 namespace action {
 
-class ActionRequestHandler : public IRequestHandler, common::IActionResultHandler {
+class ActionRequestHandler : public IRequestHandler,
+                             common::IActionResultHandler {
  public:
   ActionRequestHandler();
   ~ActionRequestHandler();
@@ -41,7 +42,7 @@ class ActionRequestHandler : public IRequestHandler, common::IActionResultHandle
   void OnGetActionId(const std::string& user_description,
                      int top_k,
                      float search_threshold) override;
-  void OnExecute(const std::string& instance, pid_t pid, uid_t uid,
+  int OnExecute(const std::string& instance, pid_t pid, uid_t uid,
                  rpc::ActionModel& model) override;
   void RegisterRequestReplyHandler(const std::string& requester,
                                    IRequestReplyHandler* handler) override;
index fdf632d7414f70f389bacc4e45e29636947a8c0b..a5c090568465fad8bbb991d50637f150fe52043c 100644 (file)
@@ -37,9 +37,9 @@ class IRequestHandler {
   virtual rpc::ActionSchema OnGetAction(const std::string& id) = 0;
   virtual void OnGetActionId(const std::string& user_description, int top_k,
       float search_threshold) = 0;
-  virtual void OnExecute(const std::string& requester, pid_t pid, uid_t uid, rpc::ActionModel& model) = 0;
+  virtual int OnExecute(const std::string& requester, pid_t pid, uid_t uid, rpc::ActionModel& model) = 0;
   virtual void RegisterRequestReplyHandler(const std::string& requester,
-      IRequestReplyHandler* handler) = 0;
+                                           IRequestReplyHandler* handler) = 0;
   virtual void UnregisterRequestReplyHandler(const std::string& requester) = 0;
 };
 
index 1f65214ca9280b1d4fd6a8b3ddb5deb377457bfd..015c1845ee7925911a05d963c29d0827c0bee393 100644 (file)
@@ -63,8 +63,7 @@ std::vector<rpc::VectorDbResult> Service::GetActionId(
 
 int Service::Execute(rpc::ActionModel action) {
   LOG(DEBUG) << "Execute : " << action.Getaction_id();
-  handler_.OnExecute(GetInstance(), GetPid(), GetUid(), action);
-  return 0;
+  return handler_.OnExecute(GetInstance(), GetPid(), GetUid(), action);
 }
 
 int Service::RegisterActionReplyCb(std::unique_ptr<ActionReplyCb> cb) {
index bf0a9793f6e18e4bcb96c4c592fa1ad7c96e81cf..fbf1e076864c31c5713a9adb98652114376e9e88 100644 (file)
 #include "action_tool/tizen_action_service_proxy.h"
 #include "log_private.hh"
 
-
 namespace action_tool {
 namespace {
 
 constexpr const char kStubAppId[] = "org.tizen.action-framework.service";
 
+GMainLoop* mainloop = nullptr;
+
 }  // namespace
 
 namespace rpc = rpc_port::tizen_action_service_proxy;
@@ -37,12 +38,13 @@ class Reply : public ActionReplyCb {
  public:
   void OnReceived(std::string result) {
     _I("result : %s", result.c_str());
+    g_main_loop_quit(mainloop);
   }
 };
 
 class Execute : public ActionTool,
-                  rpc_port::tizen_action_service_proxy::proxy::ActionService::
-                      IEventListener {
+                rpc_port::tizen_action_service_proxy::proxy::ActionService::
+                    IEventListener {
  public:
   Execute()
       : ActionTool("execute", "Execute", "execute <action id> <json string>"),
@@ -51,6 +53,7 @@ class Execute : public ActionTool,
   virtual ~Execute() {}
 
   void SetUp() override {
+    mainloop = g_main_loop_new(nullptr, FALSE);
     try {
       proxy_.Connect(true);
       connected = true;
@@ -77,6 +80,8 @@ class Execute : public ActionTool,
         proxy_.UnregisterActionReplyCb(cb_id_);
       proxy_.Disconnect();
     }
+
+    g_main_loop_unref(mainloop);
   }
 
   int Run(int argc, char** argv) override {
@@ -96,6 +101,9 @@ class Execute : public ActionTool,
     action.Setjson(json);
     try {
       int ret = proxy_.Execute(action);
+      if (ret == 0)
+        g_main_loop_run(mainloop);
+
       return ret;
     } catch (...) {
       _E("Execute Failed");