[OTA] Add Linux implementation of OTAImageProcessorInterface

examples/ota-requestor-app/linux/BUILD.gn

@@ -17,6 +17,7 @@ import("//build_overrides/chip.gni")
 
 executable("chip-ota-requestor-app") {
  sources = [
+ "LinuxOTAImageProcessor.cpp",
  "LinuxOTARequestorDriver.cpp",
  "main.cpp",
  ]

examples/ota-requestor-app/linux/LinuxOTAImageProcessor.cpp

@@ -0,0 +1,204 @@
+/*
+ *
+ * Copyright (c) 2021 Project CHIP Authors
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <app/clusters/ota-requestor/OTADownloader.h>
+
+#include "LinuxOTAImageProcessor.h"
+
+namespace chip {
+
+// TODO: Dummy function to be removed once BDX downloader is implemented and can return a real instance
+OTADownloader * GetDownloaderInstance()
+{
+ return nullptr;
+}
+
+CHIP_ERROR LinuxOTAImageProcessor::PrepareDownload()
+{
+ if (mParams.imageFile.empty())
+ {
+ ChipLogError(SoftwareUpdate, "Invalid output image file supplied");
+ return CHIP_ERROR_INTERNAL;
+ }
+
+ DeviceLayer::PlatformMgr().ScheduleWork(HandlePrepareDownload, reinterpret_cast<intptr_t>(this));
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LinuxOTAImageProcessor::Finalize()
+{
+ DeviceLayer::PlatformMgr().ScheduleWork(HandleFinalize, reinterpret_cast<intptr_t>(this));
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LinuxOTAImageProcessor::Abort()
+{
+ if (mParams.imageFile.empty())
+ {
+ ChipLogError(SoftwareUpdate, "Invalid output image file supplied");
+ return CHIP_ERROR_INTERNAL;
+ }
+
+ DeviceLayer::PlatformMgr().ScheduleWork(HandleAbort, reinterpret_cast<intptr_t>(this));
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LinuxOTAImageProcessor::ProcessBlock(ByteSpan & block)
+{
+ if (!mOfs.is_open() || !mOfs.good())
+ {
+ return CHIP_ERROR_INTERNAL;
+ }
+
+ if ((block.data() == nullptr) || block.empty())
+ {
+ return CHIP_ERROR_INVALID_ARGUMENT;
+ }
+
+ // Store block data for HandleProcessBlock to access
+ CHIP_ERROR err = SetBlock(block);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogError(SoftwareUpdate, "Cannot set block data: %" CHIP_ERROR_FORMAT, err.Format());
+ }
+
+ DeviceLayer::PlatformMgr().ScheduleWork(HandleProcessBlock, reinterpret_cast<intptr_t>(this));
+ return CHIP_NO_ERROR;
+}
+
+void LinuxOTAImageProcessor::HandlePrepareDownload(intptr_t context)
+{
+ OTADownloader * downloader = GetDownloaderInstance();
+ if (downloader == nullptr)
+ {
+ ChipLogError(SoftwareUpdate, "No known OTA downloader");
+ return;
+ }
+
+ auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
+ if (imageProcessor == nullptr)
+ {
+ downloader->OnPreparedForDownload(CHIP_ERROR_INVALID_ARGUMENT);
+ return;
+ }
+
+ imageProcessor->mOfs.open(imageProcessor->mParams.imageFile.data(),
+ std::ofstream::out | std::ofstream::ate | std::ofstream::app);
+ if (!imageProcessor->mOfs.good())
+ {
+ downloader->OnPreparedForDownload(CHIP_ERROR_OPEN_FAILED);
+ return;
+ }
+
+ downloader->OnPreparedForDownload(CHIP_NO_ERROR);
+}
+
+void LinuxOTAImageProcessor::HandleFinalize(intptr_t context)
+{
+ auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
+ if (imageProcessor == nullptr)
+ {
+ return;
+ }
+
+ imageProcessor->mOfs.close();
+ imageProcessor->ReleaseBlock();
+}
+
+void LinuxOTAImageProcessor::HandleAbort(intptr_t context)
+{
+ auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
+ if (imageProcessor == nullptr)
+ {
+ return;
+ }
+
+ imageProcessor->mOfs.close();
+ remove(imageProcessor->mParams.imageFile.data());
+ imageProcessor->ReleaseBlock();
+}
+
+void LinuxOTAImageProcessor::HandleProcessBlock(intptr_t context)
+{
+ OTADownloader * downloader = GetDownloaderInstance();
+ if (downloader == nullptr)
+ {
+ ChipLogError(SoftwareUpdate, "No known OTA downloader");
+ return;
+ }
+
+ auto * imageProcessor = reinterpret_cast<LinuxOTAImageProcessor *>(context);
+ if (imageProcessor == nullptr)
+ {
+ downloader->OnBlockProcessed(CHIP_ERROR_INVALID_ARGUMENT, OTADownloader::kEnd);
+ return;
+ }
+
+ // TODO: Process block header if any
+
+ if (!imageProcessor->mOfs.write(reinterpret_cast<const char *>(imageProcessor->mBlock.data()),
+ static_cast<std::streamsize>(imageProcessor->mBlock.size())))
+ {
+ downloader->OnBlockProcessed(CHIP_ERROR_WRITE_FAILED, OTADownloader::kEnd);
+ return;
+ }
+
+ imageProcessor->mParams.downloadedBytes += imageProcessor->mBlock.size();
+ downloader->OnBlockProcessed(CHIP_NO_ERROR, OTADownloader::kGetNext);
+}
+
+CHIP_ERROR LinuxOTAImageProcessor::SetBlock(ByteSpan & block)
+{
+ if ((block.data() == nullptr) || block.empty())
+ {
+ return CHIP_NO_ERROR;
+ }
+
+ // Allocate memory for block data if it has not been done yet
+ if (mBlock.empty())
+ {
+ mBlock = MutableByteSpan(static_cast<uint8_t *>(chip::Platform::MemoryAlloc(block.size())), block.size());
+ if (mBlock.data() == nullptr)
+ {
+ return CHIP_ERROR_NO_MEMORY;
+ }
+ }
+
+ // Store the actual block data
+ CHIP_ERROR err = CopySpanToMutableSpan(block, mBlock);
+ if (err != CHIP_NO_ERROR)
+ {
+ ChipLogError(SoftwareUpdate, "Cannot copy block data: %" CHIP_ERROR_FORMAT, err.Format());
+ return err;
+ }
+
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR LinuxOTAImageProcessor::ReleaseBlock()
+{
+ if (mBlock.data() != nullptr)
+ {
+ chip::Platform::MemoryFree(mBlock.data());
+ }
+
+ mBlock = MutableByteSpan();
+ return CHIP_NO_ERROR;
+}
+
+} // namespace chip

examples/ota-requestor-app/linux/LinuxOTAImageProcessor.h

@@ -16,30 +16,43 @@
  * limitations under the License.
  */
 
-/* This file contains the decalarions for the Linux implementation of the
- * the OTAImageProcessorDriver interface class
- */
-
-#include "app/clusters/ota-requestor/OTAImageProcessor.h"
-
-class LinuxOTAImageProcessor : public OTAImageProcessorDriver
-{
+#pragma once
 
- // Virtuial functions from OTAImageProcessorDriver -- start
- // Open file, find block of space in persistent memory, or allocate a buffer, etc.
- CHIP_ERROR PrepareDownload() { return CHIP_NO_ERROR; }
+#include <app/clusters/ota-requestor/OTAImageProcessor.h>
+#include <platform/CHIPDeviceLayer.h>
 
- // Must not be a blocking call to support cases that require IO to elements such as // external peripherals/radios
- CHIP_ERROR ProcessBlock(chip::ByteSpan & data) { return CHIP_NO_ERROR; }
+#include <fstream>
 
- // Close file, close persistent storage, etc
- CHIP_ERROR Finalize() { return CHIP_NO_ERROR; }
+namespace chip {
 
- chip::Optional<uint8_t> PercentComplete() { return chip::Optional<uint8_t>(0); }
-
- // Clean up the download which could mean erasing everything that was written,
- // releasing buffers, etc.
- CHIP_ERROR Abort() { return CHIP_NO_ERROR; }
-
- // Virtuial functions from OTAImageProcessorDriver -- end
+class LinuxOTAImageProcessor : public OTAImageProcessorInterface
+{
+public:
+ //////////// OTAImageProcessorInterface Implementation ///////////////
+ CHIP_ERROR PrepareDownload() override;
+ CHIP_ERROR Finalize() override;
+ CHIP_ERROR Abort() override;
+ CHIP_ERROR ProcessBlock(ByteSpan & block) override;
+
+private:
+ //////////// Actual handlers for the OTAImageProcessorInterface ///////////////
+ static void HandlePrepareDownload(intptr_t context);
+ static void HandleFinalize(intptr_t context);
+ static void HandleAbort(intptr_t context);
+ static void HandleProcessBlock(intptr_t context);
+
+ /**
+ * Called to allocate memory for mBlock if necessary and set it to block
+ */
+ CHIP_ERROR SetBlock(ByteSpan & block);
+
+ /**
+ * Called to release allocated memory for mBlock
+ */
+ CHIP_ERROR ReleaseBlock();
+
+ std::ofstream mOfs;
+ MutableByteSpan mBlock;
 };
+
+} // namespace chip

examples/ota-requestor-app/linux/main.cpp

@@ -33,9 +33,11 @@ using chip::CharSpan;
 using chip::DeviceProxy;
 using chip::EndpointId;
 using chip::FabricIndex;
+using chip::LinuxOTAImageProcessor;
 using chip::NodeId;
 using chip::OnDeviceConnected;
 using chip::OnDeviceConnectionFailure;
+using chip::OTADownloader;
 using chip::PeerId;
 using chip::Server;
 using chip::VendorId;

src/app/clusters/ota-requestor/OTADownloader.h

@@ -27,6 +27,8 @@
 
 #pragma once
 
+namespace chip {
+
 // A class that abstracts the image download functionality from the particular
 // protocol used for that (BDX or possibly HTTPS)
 class OTADownloader
@@ -38,7 +40,7 @@ class OTADownloader
  void virtual BeginDownload(){};
 
  // Platform calls this method upon the completion of PrepareDownload() processing
- void virtual OnPreparedForDownload(){};
+ void virtual OnPreparedForDownload(CHIP_ERROR status){};
 
  // Action parameter type for the OnBlockProcessed()
  enum BlockActionType
@@ -48,22 +50,24 @@ class OTADownloader
  };
 
  // Platform calls this method upon the completion of ProcessBlock() processing
- void virtual OnBlockProcessed(BlockActionType action){};
+ void virtual OnBlockProcessed(CHIP_ERROR status, BlockActionType action){};
 
  // A setter for the delegate class pointer
- void SetImageProcessorDelegate(OTAImageProcessorDriver * delegate) { mImageProcessorDelegate = delegate; }
+ void SetImageProcessorDelegate(OTAImageProcessorInterface * delegate) { mImageProcessorDelegate = delegate; }
 
  // API declarations end
 
  // Destructor
  virtual ~OTADownloader() = default;
 
 private:
- OTAImageProcessorDriver * mImageProcessorDelegate;
+ OTAImageProcessorInterface * mImageProcessorDelegate;
 };
 
 // Set the object implementing OTADownloader
 void SetDownloaderInstance(OTADownloader * instance);
 
 // Get the object implementing OTADownloaderInterface
 OTADownloader * GetDownloaderInstance();
+
+} // namespace chip