firmware_package.h

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <expected>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include "node/hardware_description.h"
#include "node/integro_variant.h"
 
namespace mm::node {
 
 
inline constexpr std::array<std::string_view, 2> kDefaultSkippedFirmwareFiles = {
    "SOMANET_CiA_402.xml.zip",
    "stack_image.svg.zip",
};
 
struct FirmwarePackageName {
  std::string description;             
  std::string hardwareName;            
  std::string fullFirmwareDescriptor;  
  std::string softwareName;            
  std::string softwareVersion;         
 
  std::optional<std::string> firmwareId;        
  std::optional<std::string> firmwareVersion;   
  std::optional<std::string> keyId;             
  std::optional<std::string> fieldbusProtocol;  
 
  std::optional<std::string> buildDescriptor() const;
};
 
std::expected<FirmwarePackageName, std::string> parseFirmwarePackageName(std::string_view filename);
 
void to_json(nlohmann::json& j, const FirmwarePackageName& name);
 
struct FirmwarePackageFile {
  std::string name;              
  std::vector<uint8_t> content;  
};
 
struct FirmwarePackage {
  std::optional<FirmwarePackageFile> appBinary;  
  std::optional<FirmwarePackageFile> comBinary;  
  std::optional<FirmwarePackageFile> sii;        
  std::vector<FirmwarePackageFile> extras;       
  std::vector<std::string> skipped;              
};
 
std::expected<FirmwarePackage, std::string> openFirmwarePackage(
    std::span<const uint8_t> zip, std::span<const std::string> skipFiles);
 
struct FullFirmwareDescriptors {
  std::optional<std::string> assembly;
 
  std::string device;
};
 
FullFirmwareDescriptors fullFirmwareDescriptors(const HardwareDescription& description,
                                                const IntegroVariant* variant);
 
enum class FirmwareMatch {
  kNone,      
  kAssembly,  
  kDevice,    
};
 
std::string_view toString(FirmwareMatch match);
 
struct FirmwareCompatibility {
  FirmwareMatch match = FirmwareMatch::kNone;  
  FirmwarePackageName packageName;             
  FullFirmwareDescriptors deviceDescriptors;   
 
  std::string explanation;
 
  bool compatible() const { return match != FirmwareMatch::kNone; }
};
 
FirmwareCompatibility checkFirmwareCompatibility(const HardwareDescription& description,
                                                 const FirmwarePackageName& packageName,
                                                 const IntegroVariant* variant = nullptr);
 
std::expected<FirmwareCompatibility, std::string> checkFirmwareCompatibility(
    std::string_view hardwareDescriptionContent, std::string_view packageFilename,
    const IntegroVariant* variant = nullptr);
 
void to_json(nlohmann::json& j, const FullFirmwareDescriptors& descriptors);
void to_json(nlohmann::json& j, const FirmwareCompatibility& compatibility);
 
}  // namespace mm::node