Feature sm im

src/cm/database/database.hpp

@@ -38,7 +38,7 @@ class Database : public DatabaseItf, public common::database::Database, public n
     /**
      * Destructor.
      */
-    ~Database();
+    ~Database() override;
 
     /**
      * Initializes database.

src/cm/smcontroller/smcontroller.cpp

@@ -279,25 +279,29 @@ grpc::Status SMController::RegisterSM(grpc::ServerContext*
     return grpc::Status::OK;
 }
 
-grpc::Status SMController::GetBlobsInfos(grpc::ServerContext*, const servicemanager::v5::BlobsInfosRequest* request,
-    servicemanager::v5::BlobsInfos* response)
+grpc::Status SMController::GetBlobsInfo(
+    grpc::ServerContext*, const servicemanager::v5::BlobsInfoRequest* request, servicemanager::v5::BlobInfo* response)
 {
-    LOG_DBG() << "Get blobs info request received" << Log::Field("digestsCount", request->digests_size());
+    LOG_DBG() << "Get blob info request received" << Log::Field("digest", request->digest().c_str());
 
     auto blobInfo = std::make_unique<BlobInfo>();
 
-    for (int i = 0; i < request->digests_size(); ++i) {
-        if (auto err = mBlobInfoProvider->GetBlobInfo(request->digests(i).c_str(), *blobInfo); !err.IsNone()) {
-            return grpc::Status(grpc::StatusCode::INTERNAL, err.Message());
-        }
+    auto err = mBlobInfoProvider->GetBlobInfo(request->digest().c_str(), *blobInfo);
+    if (err.IsNone() && blobInfo->mURLs.IsEmpty()) {
+        err = Error(ErrorEnum::eNotFound, "blob has no URLs");
+    }
 
-        if (blobInfo->mURLs.IsEmpty()) {
-            return grpc::Status(grpc::StatusCode::INTERNAL, "blob has no URLs");
-        }
+    // The error is returned in the response, so SM gets its code, e.g. integrity error of the CM copy.
+    if (!err.IsNone()) {
+        LOG_ERR() << "Failed to get blob info" << Log::Field("digest", request->digest().c_str()) << Log::Field(err);
 
-        response->add_urls(blobInfo->mURLs[0].CStr());
+        common::pbconvert::SetErrorInfo(err, *response);
+
+        return grpc::Status::OK;
     }
 
+    common::pbconvert::ConvertToProto(*blobInfo, *response);
+
     return grpc::Status::OK;
 }
 

src/cm/smcontroller/smcontroller.hpp

@@ -190,8 +190,8 @@ class SMController : public SMControllerItf,
         grpc::ServerReaderWriter<servicemanager::v5::SMIncomingMessages, servicemanager::v5::SMOutgoingMessages>*
             stream) override;
 
-    grpc::Status GetBlobsInfos(grpc::ServerContext* context, const servicemanager::v5::BlobsInfosRequest* request,
-        servicemanager::v5::BlobsInfos* response) override;
+    grpc::Status GetBlobsInfo(grpc::ServerContext* context, const servicemanager::v5::BlobsInfoRequest* request,
+        servicemanager::v5::BlobInfo* response) override;
 
     //
     // NetworkService::Service GRPC service methods

src/cm/smcontroller/tests/smcontroller.cpp

@@ -9,6 +9,7 @@
 #include <core/common/tests/utils/log.hpp>
 
 #include <cm/smcontroller/smcontroller.hpp>
+#include <common/pbconvert/sm.hpp>
 
 #include "stubs/alertsreceiverstub.hpp"
 #include "stubs/blobinfoproviderstub.hpp"
@@ -842,7 +843,7 @@ TEST_F(SMControllerTest, OnCertKeyChanged)
     EXPECT_TRUE(err.IsNone()) << err.Message();
 }
 
-TEST_F(SMControllerTest, GetBlobsInfos)
+TEST_F(SMControllerTest, GetBlobsInfo)
 {
     const std::string digest1 = "sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
     const std::string digest2 = "sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
@@ -866,14 +867,23 @@ TEST_F(SMControllerTest, GetBlobsInfos)
     err = mSMInfoReceiver.WaitSMInfo(cMainNodeID);
     ASSERT_TRUE(err.IsNone()) << err.Message();
 
-    // 4) Call GetBlobsInfos
-    servicemanager::v5::BlobsInfos responseBlobsInfos;
-    std::vector<std::string>       digests = {digest2, digest1};
-    ASSERT_TRUE(client.GetBlobsInfos(digests, responseBlobsInfos).IsNone());
+    // 4) Call GetBlobsInfo
+    servicemanager::v5::BlobInfo blobInfo;
 
-    ASSERT_EQ(responseBlobsInfos.urls_size(), 2);
-    EXPECT_EQ(responseBlobsInfos.urls(0), url2);
-    EXPECT_EQ(responseBlobsInfos.urls(1), url1);
+    ASSERT_TRUE(client.GetBlobsInfo(digest1, blobInfo).IsNone());
+
+    EXPECT_FALSE(blobInfo.has_error());
+    ASSERT_EQ(blobInfo.urls_size(), 2);
+    EXPECT_EQ(blobInfo.urls(0), url1);
+    EXPECT_EQ(blobInfo.urls(1), "https://backup.example.com/blob1.tar");
+
+    blobInfo.Clear();
+
+    ASSERT_TRUE(client.GetBlobsInfo(digest2, blobInfo).IsNone());
+
+    EXPECT_FALSE(blobInfo.has_error());
+    ASSERT_EQ(blobInfo.urls_size(), 1);
+    EXPECT_EQ(blobInfo.urls(0), url2);
 
     // 5) Stop client
     err = client.Stop();
@@ -884,7 +894,7 @@ TEST_F(SMControllerTest, GetBlobsInfos)
     EXPECT_TRUE(err.IsNone()) << err.Message();
 }
 
-TEST_F(SMControllerTest, GetBlobsInfosFails)
+TEST_F(SMControllerTest, GetBlobsInfoFails)
 {
     const std::string knownDigest   = "sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
     const std::string noURLsDigest  = "sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
@@ -904,15 +914,28 @@ TEST_F(SMControllerTest, GetBlobsInfosFails)
     err = mSMInfoReceiver.WaitSMInfo(cMainNodeID);
     ASSERT_TRUE(err.IsNone()) << err.Message();
 
-    servicemanager::v5::BlobsInfos responseBlobsInfos;
+    // The provider error is returned in the response with its code.
+    servicemanager::v5::BlobInfo blobInfo;
+
+    ASSERT_TRUE(client.GetBlobsInfo(unknownDigest, blobInfo).IsNone());
+
+    ASSERT_TRUE(blobInfo.has_error());
+    EXPECT_TRUE(common::pbconvert::ConvertFromProto(blobInfo.error()).Is(ErrorEnum::eNotFound));
+    EXPECT_EQ(blobInfo.urls_size(), 0);
+
+    blobInfo.Clear();
+
+    ASSERT_TRUE(client.GetBlobsInfo(noURLsDigest, blobInfo).IsNone());
+
+    ASSERT_TRUE(blobInfo.has_error());
+    EXPECT_NE(blobInfo.error().message().find("blob has no URLs"), std::string::npos) << blobInfo.error().message();
 
-    EXPECT_FALSE(client.GetBlobsInfos({knownDigest, unknownDigest}, responseBlobsInfos).IsNone());
+    blobInfo.Clear();
 
-    responseBlobsInfos.Clear();
+    ASSERT_TRUE(client.GetBlobsInfo(knownDigest, blobInfo).IsNone());
 
-    err = client.GetBlobsInfos({noURLsDigest}, responseBlobsInfos);
-    EXPECT_FALSE(err.IsNone());
-    EXPECT_NE(std::string(err.Message()).find("blob has no URLs"), std::string::npos) << err.Message();
+    EXPECT_FALSE(blobInfo.has_error());
+    EXPECT_EQ(blobInfo.urls_size(), 1);
 
     err = client.Stop();
     ASSERT_TRUE(err.IsNone()) << err.Message();

src/cm/smcontroller/tests/stubs/smclientstub.hpp

@@ -371,21 +371,20 @@ class SMClientStub {
         return ErrorEnum::eNone;
     }
 
-    Error GetBlobsInfos(const std::vector<std::string>& digests, servicemanager::v5::BlobsInfos& blobsInfos)
+    Error GetBlobsInfo(const std::string& digest, servicemanager::v5::BlobInfo& blobInfo)
     {
         std::lock_guard lock {mMutex};
 
         if (!mStub) {
             return AOS_ERROR_WRAP(Error(ErrorEnum::eFailed, "stub not available"));
         }
 
-        servicemanager::v5::BlobsInfosRequest request;
-        for (const auto& digest : digests) {
-            request.add_digests(digest);
-        }
+        servicemanager::v5::BlobsInfoRequest request;
+
+        request.set_digest(digest);
 
         grpc::ClientContext context;
-        auto                status = mStub->GetBlobsInfos(&context, request, &blobsInfos);
+        auto                status = mStub->GetBlobsInfo(&context, request, &blobInfo);
 
         if (!status.ok()) {
             return AOS_ERROR_WRAP(Error(ErrorEnum::eFailed, status.error_message().c_str()));

src/common/fileserver/fileserver.cpp

@@ -66,7 +66,7 @@
     return err == EIO || err == EBADMSG || err == EUCLEAN || err == EILSEQ;
 }
 
 int StatusFromErrno(int err)
 {
     if (IsIntegrityError(err)) {
         return common::utils::cIntegrityHTTPStatus;
@@ -79,7 +79,7 @@
     return Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR;
 }
 
 ssize_t ReadChunk(const Fileserver::ReadFunction& readFunc, int fd, std::vector<char>& buffer)
 {
     ssize_t size = 0;
 
@@ -90,7 +90,7 @@
     return size;
 }
 
 void SendStatus(Poco::Net::HTTPServerResponse& response, int status)
 {
     if (status == common::utils::cIntegrityHTTPStatus) {
         response.setStatus(std::to_string(status));
@@ -284,10 +284,10 @@
     return !relative.empty() && *relative.begin() != "..";
 }
 
 Fileserver::FileRequestHandler::FDPtr Fileserver::FileRequestHandler::OpenFile(
     const std::string& path, struct stat& st, Poco::Net::HTTPServerResponse& response)
 {
-    FDPtr fd(open(path.c_str(), O_RDONLY | O_CLOEXEC | O_NONBLOCK));
+    FDPtr fd(FDHandle(open(path.c_str(), O_RDONLY | O_CLOEXEC | O_NONBLOCK)));
     if (!fd) {
         auto err = errno;
 
@@ -330,20 +330,20 @@
 }
 
 void Fileserver::FileRequestHandler::HandleReadError(
     const std::string& path, const struct stat& st, int err, Poco::Net::HTTPServerResponse& response)
 {
     LOG_ERR() << "Failed to read file" << Log::Field("path", path.c_str()) << Log::Field("sent", response.sent())
               << Log::Field(Error(err, "can't read file"));
 
     if (!response.sent()) {
         SendStatus(response, StatusFromErrno(err));
     } else if (IsIntegrityError(err)) {
         mBrokenFiles->Mark(path, st.st_mtim);
     }
 }
 
 void Fileserver::FileRequestHandler::SendFile(int fd, const std::string& path, const struct stat& st,
     const std::string& extension, Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)
 {
     std::vector<char> buffer(cReadChunkSize);
 

src/common/fileserver/fileserver.hpp

@@ -173,8 +173,10 @@
         struct FDHandle {
             int mFD = -1;
 
+            // Implicit conversion from nullptr is required by unique_ptr pointer type.
+            // cppcheck-suppress noExplicitConstructor
             FDHandle(std::nullptr_t = nullptr) { }
-            FDHandle(int fd)
+            explicit FDHandle(int fd)
                 : mFD(fd)
             {
             }
@@ -194,7 +196,7 @@
             void operator()(FDHandle handle) const { close(handle.mFD); }
         };
 
         using FDPtr = std::unique_ptr<int, FDCloser>;
 
         /**
          * Resolves request target to a file path inside the root directory.
@@ -237,7 +239,7 @@
          * @param request request.
          * @param response response.
          */
         void SendFile(int fd, const std::string& path, const struct stat& st, const std::string& extension,
             Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response);
 
         std::string                  mRootDir;

src/common/pbconvert/sm.cpp

@@ -1309,4 +1309,42 @@ Error ConvertFromProto(const servicemanager::v5::InstanceNetworkStateInfo& src,
     return ErrorEnum::eNone;
 }
 
+void ConvertToProto(const BlobInfo& src, servicemanager::v5::BlobInfo& dst)
+{
+    for (const auto& url : src.mURLs) {
+        dst.add_urls(url.CStr());
+    }
+
+    dst.set_sha256(std::string(reinterpret_cast<const char*>(src.mSHA256.Get()), src.mSHA256.Size()));
+    dst.set_size(src.mSize);
+}
+
+Error ConvertFromProto(const servicemanager::v5::BlobInfo& src, const String& digest, BlobInfo& dst)
+{
+    if (auto err = dst.mDigest.Assign(digest); !err.IsNone()) {
+        return AOS_ERROR_WRAP(err);
+    }
+
+    // The proto doesn't carry the decrypt and sign info, so the fields of a reused blob info are reset.
+    dst.mURLs.Clear();
+    dst.mDecryptInfo.Reset();
+    dst.mSignInfo.Reset();
+
+    for (const auto& url : src.urls()) {
+        if (auto err = dst.mURLs.PushBack(url.c_str()); !err.IsNone()) {
+            return AOS_ERROR_WRAP(err);
+        }
+    }
+
+    if (auto err = dst.mSHA256.Assign(
+            Array<uint8_t>(reinterpret_cast<const uint8_t*>(src.sha256().data()), src.sha256().size()));
+        !err.IsNone()) {
+        return AOS_ERROR_WRAP(err);
+    }
+
+    dst.mSize = src.size();
+
+    return ErrorEnum::eNone;
+}
+
 } // namespace aos::common::pbconvert

src/common/pbconvert/sm.hpp

@@ -15,6 +15,7 @@
 #include <core/common/monitoring/monitoring.hpp>
 #include <core/common/networkmanager/itf/pendingupdatehandler.hpp>
 #include <core/common/types/alerts.hpp>
+#include <core/common/types/blobs.hpp>
 #include <core/common/types/common.hpp>
 #include <core/common/types/envvars.hpp>
 #include <core/common/types/instance.hpp>
@@ -344,6 +345,24 @@ Error ConvertToProto(const InstanceNetworkStateInfo& src, servicemanager::v5::In
  */
 Error ConvertFromProto(const servicemanager::v5::InstanceNetworkStateInfo& src, InstanceNetworkStateInfo& dst);
 
+/**
+ * Converts Aos blob info to grpc BlobInfo.
+ *
+ * @param src Aos blob info.
+ * @param[out] dst grpc blob info.
+ */
+void ConvertToProto(const BlobInfo& src, servicemanager::v5::BlobInfo& dst);
+
+/**
+ * Converts grpc BlobInfo to Aos.
+ *
+ * @param src grpc blob info.
+ * @param digest blob digest.
+ * @param[out] dst Aos blob info.
+ * @return Error.
+ */
+Error ConvertFromProto(const servicemanager::v5::BlobInfo& src, const String& digest, BlobInfo& dst);
+
 } // namespace aos::common::pbconvert
 
 #endif

src/common/pbconvert/tests/sm.cpp

@@ -805,4 +805,57 @@ TEST_F(PBConvertSMTest, ConvertInstanceNetworkParamsToAllocateInstanceNetworkRes
     EXPECT_EQ(result.dns_servers_size(), 0);
 }
 
+TEST_F(PBConvertSMTest, ConvertBlobInfoToProto)
+{
+    const uint8_t cSHA256[] = {0x01, 0x02, 0x03, 0x04};
+
+    auto blobInfo = std::make_unique<BlobInfo>();
+
+    blobInfo->mDigest = "sha256:blob";
+    blobInfo->mSize   = 1024;
+
+    ASSERT_TRUE(blobInfo->mURLs.PushBack("https://example.com/blob1").IsNone());
+    ASSERT_TRUE(blobInfo->mURLs.PushBack("https://example.com/blob2").IsNone());
+    ASSERT_TRUE(blobInfo->mSHA256.Assign(Array<uint8_t>(cSHA256, sizeof(cSHA256))).IsNone());
+
+    servicemanager::v5::BlobInfo result;
+
+    ConvertToProto(*blobInfo, result);
+
+    ASSERT_EQ(result.urls_size(), 2);
+    EXPECT_EQ(result.urls(0), "https://example.com/blob1");
+    EXPECT_EQ(result.urls(1), "https://example.com/blob2");
+    EXPECT_EQ(result.sha256(), std::string("\x01\x02\x03\x04"));
+    EXPECT_EQ(result.size(), 1024);
+    EXPECT_FALSE(result.has_error());
+}
+
+TEST_F(PBConvertSMTest, ConvertBlobInfoFromProto)
+{
+    const uint8_t cSHA256[] = {0x01, 0x02, 0x03, 0x04};
+
+    servicemanager::v5::BlobInfo grpcData;
+
+    grpcData.add_urls("https://example.com/blob1");
+    grpcData.add_urls("https://example.com/blob2");
+    grpcData.set_sha256(std::string("\x01\x02\x03\x04"));
+    grpcData.set_size(1024);
+
+    auto blobInfo = std::make_unique<BlobInfo>();
+
+    ASSERT_TRUE(blobInfo->mURLs.PushBack("https://example.com/stale").IsNone());
+
+    auto err = ConvertFromProto(grpcData, "sha256:blob", *blobInfo);
+    ASSERT_TRUE(err.IsNone()) << err.Message();
+
+    EXPECT_EQ(blobInfo->mDigest, "sha256:blob");
+    ASSERT_EQ(blobInfo->mURLs.Size(), 2);
+    EXPECT_EQ(blobInfo->mURLs[0], "https://example.com/blob1");
+    EXPECT_EQ(blobInfo->mURLs[1], "https://example.com/blob2");
+    EXPECT_EQ(blobInfo->mSHA256, Array<uint8_t>(cSHA256, sizeof(cSHA256)));
+    EXPECT_EQ(blobInfo->mSize, 1024);
+    EXPECT_FALSE(blobInfo->mDecryptInfo.HasValue());
+    EXPECT_FALSE(blobInfo->mSignInfo.HasValue());
+}
+
 } // namespace aos::common::pbconvert

src/sm/app/aoscore.cpp

@@ -124,8 +124,8 @@ void AosCore::Init(const std::string& configFile)
 
     // Initialize images space allocator
 
-    err = mImagesSpaceAllocator.Init(
-        mAllocator, mConfig.mImageManager.mImagePath, mPlatformFS, mConfig.mImageManager.mPartLimit, &mImageManager);
+    err = mImagesSpaceAllocator.Init(mAllocator, mConfig.mImageManager.mImagePath, mPlatformFS,
+        mConfig.mImageManager.mPartLimit, &mImageManager.GetItemRemover());
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize images space allocator");
 
     // Initialize downloader
@@ -139,14 +139,14 @@ void AosCore::Init(const std::string& configFile)
 
     // Initialize image manager
 
-    err = mImageManager.Init(mAllocator, mConfig.mImageManager, mSMClient, mImagesSpaceAllocator, mDownloader,
-        mFileInfoProvider, mOCISpec, mImageHandler, mDatabase);
+    err = mImageManager.Init(mConfig.mImageManager, mSMClient, mDatabase, mImagesSpaceAllocator, mDownloader,
+        mImageHandler, mFileInfoProvider, mOCISpec, mPlatformFS, mAllocator);
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize image manager");
 
     // Initialize launcher
 
-    err = mLauncher.Init(mAllocator, *runtimes, mImageManager, mSMClient, mDatabase, mOCISpec, mImageManager, mSMClient,
-        mNetworkManager, mInstanceIDProvider, mResourceManager);
+    err = mLauncher.Init(mAllocator, *runtimes, mImageManager, mImageManager, mSMClient, mDatabase, mOCISpec,
+        mImageManager, mSMClient, mNetworkManager, mInstanceIDProvider, mResourceManager);
     AOS_ERROR_CHECK_AND_THROW(err, "can't initialize launcher");
 
     // Initialize node config handler

src/sm/config/config.cpp

@@ -62,7 +62,7 @@ void ParseSMClientConfig(const common::utils::CaseInsensitiveObjectWrapper& obje
 };
 
 void ParseImageManagerConfig(const common::utils::CaseInsensitiveObjectWrapper& object, const std::string& workingDir,
-    imagemanager::Config& config)
+    aos::common::imagemanager::Config& config)
 {
     Error err;
 
@@ -72,7 +72,7 @@ void ParseImageManagerConfig(const common::utils::CaseInsensitiveObjectWrapper&
 
     config.mPartLimit = object.GetValue<size_t>("imagesPartLimit", 0);
 
-    Tie(config.mUpdateItemTTL, err)
+    Tie(config.mItemCacheTTL, err)
         = common::utils::ParseDuration(object.GetValue<std::string>("updateItemTtl", cDefaultUpdateItemTTL));
     AOS_ERROR_CHECK_AND_THROW(err, "error parsing updateItemTtl tag");