Home | History | Annotate | Download | only in payload_consumer 
      1 //
      2 // Copyright (C) 2013 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #include "update_engine/payload_consumer/install_plan.h"
     18 
     19 #include <base/format_macros.h>
     20 #include <base/logging.h>
     21 #include <base/strings/string_number_conversions.h>
     22 #include <base/strings/stringprintf.h>
     23 
     24 #include "update_engine/common/utils.h"
     25 #include "update_engine/payload_consumer/payload_constants.h"
     26 
     27 using std::string;
     28 
     29 namespace chromeos_update_engine {
     30 
     31 string InstallPayloadTypeToString(InstallPayloadType type) {
     32   switch (type) {
     33     case InstallPayloadType::kUnknown:
     34       return "unknown";
     35     case InstallPayloadType::kFull:
     36       return "full";
     37     case InstallPayloadType::kDelta:
     38       return "delta";
     39   }
     40   return "invalid type";
     41 }
     42 
     43 bool InstallPlan::operator==(const InstallPlan& that) const {
     44   return ((is_resume == that.is_resume) &&
     45           (download_url == that.download_url) && (payloads == that.payloads) &&
     46           (source_slot == that.source_slot) &&
     47           (target_slot == that.target_slot) && (partitions == that.partitions));
     48 }
     49 
     50 bool InstallPlan::operator!=(const InstallPlan& that) const {
     51   return !((*this) == that);
     52 }
     53 
     54 void InstallPlan::Dump() const {
     55   string partitions_str;
     56   for (const auto& partition : partitions) {
     57     partitions_str +=
     58         base::StringPrintf(", part: %s (source_size: %" PRIu64
     59                            ", target_size %" PRIu64 ", postinst:%s)",
     60                            partition.name.c_str(),
     61                            partition.source_size,
     62                            partition.target_size,
     63                            utils::ToString(partition.run_postinstall).c_str());
     64   }
     65   string payloads_str;
     66   for (const auto& payload : payloads) {
     67     payloads_str += base::StringPrintf(
     68         ", payload: (size: %" PRIu64 ", metadata_size: %" PRIu64
     69         ", metadata signature: %s, hash: %s, payload type: %s)",
     70         payload.size,
     71         payload.metadata_size,
     72         payload.metadata_signature.c_str(),
     73         base::HexEncode(payload.hash.data(), payload.hash.size()).c_str(),
     74         InstallPayloadTypeToString(payload.type).c_str());
     75   }
     76 
     77   LOG(INFO) << "InstallPlan: " << (is_resume ? "resume" : "new_update")
     78             << ", source_slot: " << BootControlInterface::SlotName(source_slot)
     79             << ", target_slot: " << BootControlInterface::SlotName(target_slot)
     80             << ", url: " << download_url << payloads_str << partitions_str
     81             << ", hash_checks_mandatory: "
     82             << utils::ToString(hash_checks_mandatory)
     83             << ", powerwash_required: " << utils::ToString(powerwash_required);
     84 }
     85 
     86 bool InstallPlan::LoadPartitionsFromSlots(BootControlInterface* boot_control) {
     87   bool result = true;
     88   for (Partition& partition : partitions) {
     89     if (source_slot != BootControlInterface::kInvalidSlot) {
     90       result = boot_control->GetPartitionDevice(
     91           partition.name, source_slot, &partition.source_path) && result;
     92     } else {
     93       partition.source_path.clear();
     94     }
     95 
     96     if (target_slot != BootControlInterface::kInvalidSlot) {
     97       result = boot_control->GetPartitionDevice(
     98           partition.name, target_slot, &partition.target_path) && result;
     99     } else {
    100       partition.target_path.clear();
    101     }
    102   }
    103   return result;
    104 }
    105 
    106 bool InstallPlan::Partition::operator==(
    107     const InstallPlan::Partition& that) const {
    108   return (name == that.name &&
    109           source_path == that.source_path &&
    110           source_size == that.source_size &&
    111           source_hash == that.source_hash &&
    112           target_path == that.target_path &&
    113           target_size == that.target_size &&
    114           target_hash == that.target_hash &&
    115           run_postinstall == that.run_postinstall &&
    116           postinstall_path == that.postinstall_path &&
    117           filesystem_type == that.filesystem_type &&
    118           postinstall_optional == that.postinstall_optional);
    119 }
    120 
    121 }  // namespace chromeos_update_engine
    122