Expose image type detection from image_aggregator

Instances of the raw image type can only be created from the image
detection logic, since a raw image is defind by not having the magic
prefix of any special image format.

Bug: b/435218921

Author: Databean

base/cvd/cuttlefish/host/libs/image_aggregator/BUILD.bazel

@@ -26,6 +26,22 @@ cf_cc_library(
     ],
 )
 
+cf_cc_library(
+    name = "image_from_file",
+    srcs = ["image_from_file.cc"],
+    hdrs = ["image_from_file.h"],
+    deps = [
+        "//cuttlefish/common/libs/utils:files",
+        "//cuttlefish/common/libs/utils:result",
+        "//cuttlefish/host/libs/image_aggregator:composite_disk",
+        "//cuttlefish/host/libs/image_aggregator:disk_image",
+        "//cuttlefish/host/libs/image_aggregator:qcow2",
+        "//cuttlefish/host/libs/image_aggregator:raw",
+        "//cuttlefish/host/libs/image_aggregator:sparse_image",
+        "//libbase",
+    ],
+)
+
 cf_cc_library(
     name = "disk_image",
     hdrs = ["disk_image.h"],
@@ -50,7 +66,7 @@ cf_cc_library(
         "//cuttlefish/host/libs/config:mbr",
         "//cuttlefish/host/libs/image_aggregator:cdisk_spec_cc_proto",
         "//cuttlefish/host/libs/image_aggregator:composite_disk",
-        "//cuttlefish/host/libs/image_aggregator:qcow2",
+        "//cuttlefish/host/libs/image_aggregator:image_from_file",
         "//cuttlefish/host/libs/image_aggregator:sparse_image",
         "//libbase",
         "//libsparse",
@@ -59,6 +75,17 @@ cf_cc_library(
     ],
 )
 
+cf_cc_library(
+    name = "raw",
+    srcs = ["raw.cc"],
+    hdrs = ["raw.h"],
+    deps = [
+        "//cuttlefish/common/libs/utils:files",
+        "//cuttlefish/common/libs/utils:result",
+        "//cuttlefish/host/libs/image_aggregator:disk_image",
+    ],
+)
+
 cf_cc_library(
     name = "sparse_image",
     srcs = ["sparse_image.cc"],

base/cvd/cuttlefish/host/libs/image_aggregator/image_aggregator.cc

@@ -45,15 +45,13 @@
 #include "cuttlefish/host/libs/config/mbr.h"
 #include "cuttlefish/host/libs/image_aggregator/cdisk_spec.pb.h"
 #include "cuttlefish/host/libs/image_aggregator/composite_disk.h"
-#include "cuttlefish/host/libs/image_aggregator/qcow2.h"
+#include "cuttlefish/host/libs/image_aggregator/image_from_file.h"
 #include "cuttlefish/host/libs/image_aggregator/sparse_image.h"
 
 namespace cuttlefish {
 namespace {
 
 constexpr int GPT_NUM_PARTITIONS = 128;
-static const std::string CDISK_MAGIC = "composite_disk\x1d";
-static const std::string QCOW2_MAGIC = "QFI\xfb";
 
 /**
  * Creates a "Protective" MBR Partition Table header. The GUID
@@ -143,45 +141,9 @@ struct PartitionInfo {
  * images.
  */
 Result<uint64_t> ExpandedStorageSize(const std::string& file_path) {
-  android::base::unique_fd fd(open(file_path.c_str(), O_RDONLY));
-  CF_EXPECTF(fd.get() >= 0, "Could not open '{}': {}", file_path,
-             strerror(errno));
-
-  std::uint64_t file_size = FileSize(file_path);
-
-  // Try to read the disk in a nicely-aligned block size unless the whole file
-  // is smaller.
-  constexpr uint64_t MAGIC_BLOCK_SIZE = 4096;
-  std::string magic(std::min(file_size, MAGIC_BLOCK_SIZE), '\0');
-
-  CF_EXPECTF(android::base::ReadFully(fd, magic.data(), magic.size()),
-             "Failed to read '{}': {}'", file_path, strerror(errno));
-
-  CF_EXPECTF(lseek(fd, 0, SEEK_SET) != -1, "Failed to lseek('{}'): {}",
-             file_path, strerror(errno));
-
-  // Composite disk image
-  if (android::base::StartsWith(magic, CDISK_MAGIC)) {
-    CompositeDiskImage image =
-        CF_EXPECT(CompositeDiskImage::OpenExisting(file_path));
-    return CF_EXPECT(image.VirtualSizeBytes());
-  }
-
-  // Qcow2 image
-  if (android::base::StartsWith(magic, Qcow2Image::MagicString())) {
-    Qcow2Image image = CF_EXPECT(Qcow2Image::OpenExisting(file_path));
-    return CF_EXPECT(image.VirtualSizeBytes());
-  }
-
-  // Android-Sparse
-  if (android::base::StartsWith(magic, AndroidSparseImage::MagicString())) {
-    AndroidSparseImage image =
-        CF_EXPECT(AndroidSparseImage::OpenExisting(file_path));
-    return CF_EXPECT(image.VirtualSizeBytes());
-  }
-
-  // raw image file
-  return file_size;
+  std::unique_ptr<DiskImage> disk = CF_EXPECT(ImageFromFile(file_path));
+  CF_EXPECT(disk.get());
+  return CF_EXPECT(disk->VirtualSizeBytes());
 }
 
 /*
@@ -494,7 +456,7 @@ Result<void> CreateCompositeDisk(std::vector<ImagePartition> partitions,
       CF_EXPECT(builder.MakeCompositeDiskSpec(header_file, footer_file));
   std::ofstream composite(output_composite_path.c_str(),
                           std::ios::binary | std::ios::trunc);
-  composite << CDISK_MAGIC;
+  composite << CompositeDiskImage::MagicString();
   composite_proto.SerializeToOstream(&composite);
   composite.flush();
 

base/cvd/cuttlefish/host/libs/image_aggregator/image_from_file.cc

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * 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 "cuttlefish/host/libs/image_aggregator/image_from_file.h"
+
+#include <memory>
+#include <string>
+
+#include <android-base/file.h>
+#include <android-base/strings.h>
+
+#include "cuttlefish/common/libs/utils/files.h"
+#include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/libs/image_aggregator/composite_disk.h"
+#include "cuttlefish/host/libs/image_aggregator/disk_image.h"
+#include "cuttlefish/host/libs/image_aggregator/qcow2.h"
+#include "cuttlefish/host/libs/image_aggregator/raw.h"
+#include "cuttlefish/host/libs/image_aggregator/sparse_image.h"
+
+namespace cuttlefish {
+
+Result<std::unique_ptr<DiskImage>> ImageFromFile(const std::string& file_path) {
+  android::base::unique_fd fd(open(file_path.c_str(), O_RDONLY));
+  CF_EXPECTF(fd.get() >= 0, "Could not open '{}': {}", file_path,
+             strerror(errno));
+
+  std::uint64_t file_size = FileSize(file_path);
+
+  // Try to read the disk in a nicely-aligned block size unless the whole file
+  // is smaller.
+  constexpr uint64_t MAGIC_BLOCK_SIZE = 4096;
+  std::string magic(std::min(file_size, MAGIC_BLOCK_SIZE), '\0');
+
+  CF_EXPECTF(android::base::ReadFully(fd, magic.data(), magic.size()),
+             "Failed to read '{}': {}'", file_path, strerror(errno));
+
+  CF_EXPECTF(lseek(fd, 0, SEEK_SET) != -1, "Failed to lseek('{}'): {}",
+             file_path, strerror(errno));
+
+  // Composite disk image
+  if (android::base::StartsWith(magic, CompositeDiskImage::MagicString())) {
+    CompositeDiskImage image =
+        CF_EXPECT(CompositeDiskImage::OpenExisting(file_path));
+    return std::make_unique<CompositeDiskImage>(std::move(image));
+  }
+
+  // Qcow2 image
+  if (android::base::StartsWith(magic, Qcow2Image::MagicString())) {
+    Qcow2Image image = CF_EXPECT(Qcow2Image::OpenExisting(file_path));
+    return std::make_unique<Qcow2Image>(std::move(image));
+  }
+
+  // Android-Sparse
+  if (android::base::StartsWith(magic, AndroidSparseImage::MagicString())) {
+    AndroidSparseImage image =
+        CF_EXPECT(AndroidSparseImage::OpenExisting(file_path));
+    return std::make_unique<AndroidSparseImage>(std::move(image));
+  }
+
+  // raw image file
+  RawImage raw = CF_EXPECT(RawImage::OpenExisting(file_path));
+  return std::make_unique<RawImage>(std::move(raw));
+}
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/image_aggregator/image_from_file.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/libs/image_aggregator/disk_image.h"
+
+namespace cuttlefish {
+
+Result<std::unique_ptr<DiskImage>> ImageFromFile(const std::string& path);
+
+}

base/cvd/cuttlefish/host/libs/image_aggregator/raw.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * 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 "cuttlefish/host/libs/image_aggregator/raw.h"
+
+#include <string>
+#include <utility>
+
+#include "cuttlefish/common/libs/utils/files.h"
+
+namespace cuttlefish {
+
+Result<RawImage> RawImage::OpenExisting(const std::string& path) {
+  off_t size = FileSize(path);
+  CF_EXPECT_GE(size, 0, strerror(errno));
+
+  return RawImage(size);
+}
+
+RawImage::RawImage(RawImage&& other) { size_ = std::move(other.size_); }
+RawImage::~RawImage() = default;
+RawImage& RawImage::operator=(RawImage&& other) {
+  size_ = std::move(other.size_);
+  return *this;
+}
+
+Result<uint64_t> RawImage::VirtualSizeBytes() const { return size_; }
+
+RawImage::RawImage(uint64_t size) : size_(size) {}
+
+}  // namespace cuttlefish

base/cvd/cuttlefish/host/libs/image_aggregator/raw.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+
+#include "cuttlefish/common/libs/utils/result.h"
+#include "cuttlefish/host/libs/image_aggregator/disk_image.h"
+
+namespace cuttlefish {
+
+Result<std::unique_ptr<DiskImage>> ImageFromFile(const std::string& path);
+
+/** A file where the raw bytes are presented as a disk to a virtual machine. */
+class RawImage : public DiskImage {
+ public:
+  RawImage(RawImage&&);
+  ~RawImage() override;
+  RawImage& operator=(RawImage&&);
+
+  Result<uint64_t> VirtualSizeBytes() const override;
+
+ private:
+  static Result<RawImage> OpenExisting(const std::string& path);
+
+  RawImage(uint64_t size);
+
+  friend Result<std::unique_ptr<DiskImage>> ImageFromFile(
+      const std::string& path);
+
+  uint64_t size_;
+};
+
+}  // namespace cuttlefish