virt_disk 0.0.1

data/lib/virt_disk/partition_type/gpt_partition.rb

@@ -0,0 +1,71 @@
+require 'uuidtools'
+
+module VirtDisk
+  module PartitionType
+    class GptPartition < Partition
+      GPT_HEADER = BinaryStruct.new([
+        'a8',    :signature,    # 00-07: Signature "EFI PART"
+        'a4',    :version,      # 08-11: Revision
+        'L',     :header_size,  # 12-15: Header size
+        'L',     :crc32_header, # 16-19:
+        'L',     :reserved,     # 20-23:
+        'Q',     :cur_lba,      # 24-31:
+        'Q',     :bak_lba,      # 32-39:
+        'Q',     :first_lba,    # 40-47:
+        'Q',     :last_lba,     # 48-55:
+        'a16',   :guid,         # 56-71:
+        'Q',     :startLBA,     # 72-79:
+        'L',     :part_num,     # 80-83:
+        'L',     :part_size,    # 84-87:
+        'L',     :part_array,   # 88-91:
+        'a420',  :reserved2,    # 92-511:
+      ])
+
+      GPT_PARTITION_ENTRY = BinaryStruct.new([
+        'a16',   :ptype,      # 00-15: partition type
+        'a16',   :pguid,      # 16-31: partition GUID
+        'Q',     :first_lba,  # 32-39: first LBA
+        'Q',     :last_lba,   # 40-47: last LBA
+        'a8',    :attr_flag,  # 48-55: attribute flag
+        'a72',   :pname,      # 56-127: partition name
+      ])
+
+      include LogDecorator::Logging
+      include ExportMethods
+
+      def self.discover_partitions(disk) # rubocop:disable AbcSize
+        mbr = disk.mod_read(0, MBR_SIZE)
+        if mbr.length < MBR_SIZE
+          _log.info "<#{disk.object_id}> disk does not contain a master boot record"
+          return []
+        end
+
+        sig = mbr[510..511].unpack('H4')
+
+        pt_entry = DOS_PARTITION_ENTRY.decode(mbr[DOS_PT_START, PTE_LEN])
+        ptype = pt_entry[:ptype]
+
+        return [] if sig[0] != DOS_SIG || ptype != GPT_SIG
+        discover_gpt_partitions(disk)
+      end
+
+      def self.discover_gpt_partitions(disk) # rubocop:disable AbcSize
+        _log.info "Parsing GPT disk ..."
+        gpt_header = disk.mod_read(MBR_SIZE, GPT_HEADER.size)
+        header = GPT_HEADER.decode(gpt_header)
+
+        partitions = []
+        pte = GPT_HEADER.size + MBR_SIZE
+        (1..header[:part_num]).each do |n|
+          gpt = disk.mod_read(pte, GPT_PARTITION_ENTRY.size)
+          pt_entry = GPT_PARTITION_ENTRY.decode(gpt)
+          ptype = UUIDTools::UUID.parse_raw(pt_entry[:ptype]).to_s
+
+          partitions.push(new(disk, ptype, n, pt_entry[:first_lba], pt_entry[:last_lba])) if pt_entry[:first_lba] != 0
+          pte += header[:part_size]
+        end
+        partitions
+      end
+    end
+  end
+end

data/lib/virt_disk/version.rb

@@ -0,0 +1,3 @@
+module VirtDisk
+  VERSION = "0.0.1" unless const_defined?(:VERSION)
+end

data/spec/dos_partition_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "partition_shared_examples"
+
+describe "DOS Partition" do
+  let(:extpected_num_partitions) { 2 }
+  let(:expected_partition_class) { VirtDisk::PartitionType::DosPartition }
+
+  let(:per_partition_values) do
+    [
+      {
+        :ptype           => 4,
+        :block_size      => 512,
+        :start_lba       => 63,
+        :end_lba         => 575,
+        :start_byte_addr => 32256,
+        :end_byte_addr   => 294400,
+        :size            => 262144
+      },
+      {
+        :ptype           => 4,
+        :block_size      => 512,
+        :start_lba       => 575,
+        :end_lba         => 2048,
+        :start_byte_addr => 294400,
+        :end_byte_addr   => 1048576,
+        :size            => 754176
+      }
+    ]
+  end
+
+  data_dir = File.join(__dir__, "data")
+  dos_partition_file = File.join(data_dir, "dos_partition.img")
+  file_mod = VirtDisk::FileIo.new(dos_partition_file)
+  disk = VirtDisk::Disk.new(file_mod)
+
+  it "should return an array of the expected length" do
+    expect(VirtDisk::PartitionType.partition_probe(disk).length).to eq(extpected_num_partitions)
+  end
+
+  VirtDisk::PartitionType.partition_probe(disk).each do |part|
+    describe "Partition: #{part.pnum}" do
+      before(:each) do
+        @partition = part
+      end
+
+      it_should_behave_like "common_partition"
+    end
+  end
+end

data/spec/export_methods_spec.rb

@@ -0,0 +1,257 @@
+require "spec_helper"
+require "virt_disk"
+
+def new_test_class(cname, methods_exported = [], methods_not_exported = [])
+  klass = Class.new { include VirtDisk::ExportMethods }
+  stub_const cname, klass
+  add_test_methods(klass, methods_exported, methods_not_exported)
+  klass
+end
+
+def add_test_methods(klass, methods_exported, methods_not_exported)
+  klass.class_eval do
+    (methods_exported + methods_not_exported).each do |mn|
+      define_method(mn) { "In #{self.class.name}##{mn}" }
+    end
+    export(*methods_exported)
+  end
+end
+
+describe VirtDisk::ExportMethods do
+  let(:group_a_methods) do
+    %i( method1 method2 method3 )
+  end
+
+  let(:group_b_methods) do
+    %i( method4 method5 method6 )
+  end
+
+  let(:group_c_methods) do
+    %i( method7 )
+  end
+
+  describe "defined methods" do
+    before(:each) do
+      new_test_class('TestMod1')
+    end
+
+    describe "Class methods" do
+      it "should respond to export" do
+        expect(TestMod1.respond_to?(:export)).to be true
+      end
+
+      it "should respond to exports" do
+        expect(TestMod1.respond_to?(:exports)).to be true
+      end
+
+      it "should respond to exported?" do
+        expect(TestMod1.respond_to?(:exported?)).to be true
+      end
+    end
+
+    describe "Instance methods" do
+      let(:mod1_obj) { TestMod1.new }
+
+      it "should respond to exported?" do
+        expect(mod1_obj.respond_to?(:exported?)).to be true
+      end
+
+      it "should respond to delegate=" do
+        expect(mod1_obj.respond_to?(:delegate=)).to be true
+      end
+
+      it "should respond to delegate" do
+        expect(mod1_obj.respond_to?(:delegate)).to be true
+      end
+    end
+  end
+
+  describe "Class methods" do
+    describe "export" do
+      before(:each) do
+        new_test_class('TestMod1', group_a_methods, group_c_methods)
+      end
+
+      it "should raise an error when method isn't defined" do
+        expect do
+          TestMod1.export(:foo)
+        end.to raise_exception(RuntimeError, "Method not defined in class: foo")
+      end
+
+      it "should return nil on success" do
+        expect(TestMod1.export(group_c_methods.first)).to be_nil
+      end
+
+      it "should add the method to the exports list" do
+        meth = group_c_methods.first
+        expect(TestMod1.exports.include?(meth)).to be false
+        TestMod1.export(meth)
+        expect(TestMod1.exports.include?(meth)).to be true
+      end
+    end
+
+    describe "exports" do
+      before(:each) do
+        new_test_class('TestMod1', [], group_a_methods)
+      end
+
+      it "should return an empty array when nothing exported" do
+        expect(TestMod1.exports).to match_array([])
+      end
+
+      it "should return the expected array" do
+        expect(TestMod1.exports).to match_array([])
+        TestMod1.export(*group_a_methods)
+        expect(TestMod1.exports).to match_array(group_a_methods)
+      end
+    end
+
+    describe "exported?" do
+      before(:each) do
+        new_test_class('TestMod1', [], group_a_methods)
+      end
+
+      it "should return false when nothing exported" do
+        expect(TestMod1.exported?(group_a_methods.first)).to be false
+      end
+
+      it "should return false when method isn't exported" do
+        TestMod1.export(*group_a_methods)
+        expect(TestMod1.exported?(group_b_methods.first)).to be false
+      end
+
+      it "should return true when method is exported" do
+        TestMod1.export(*group_a_methods)
+        expect(TestMod1.exported?(group_a_methods.first)).to be true
+      end
+    end
+  end
+
+  describe "Instance methods" do
+    let(:no_export_obj) do
+      new_test_class('NoExportMod')
+      NoExportMod.new
+    end
+
+    let(:export_obj) do
+      new_test_class('ExportMod', group_a_methods)
+      ExportMod.new
+    end
+
+    describe "exported?" do
+      it "should return false when nothing exported" do
+        expect(no_export_obj.exported?(group_a_methods.first)).to be false
+      end
+
+      it "should return false when method isn't exported" do
+        expect(export_obj.exported?(group_b_methods.first)).to be false
+      end
+
+      it "should return true when method is exported" do
+        expect(export_obj.exported?(group_a_methods.first)).to be true
+      end
+    end
+
+    describe "delegate, delegate=" do
+      it "should return nil when no delegate" do
+        expect(no_export_obj.delegate).to be nil
+      end
+
+      it "should return the object it is passed" do
+        expect(no_export_obj.delegate = export_obj).to eq(export_obj)
+      end
+
+      it "should set the delegate accordingly" do
+        no_export_obj.delegate = export_obj
+        expect(no_export_obj.delegate).to eq(export_obj)
+      end
+    end
+  end
+
+  describe "Operation" do
+    let(:obja) do
+      new_test_class('ModA', group_a_methods)
+      ModA.new
+    end
+
+    let(:objb) do
+      new_test_class('ModB', group_b_methods)
+      ModB.new
+    end
+
+    let(:objc) do
+      new_test_class('ModC', group_c_methods)
+      ModC.new
+    end
+
+    it "should 'respond_to?' top-level methods" do
+      expect(obja.respond_to?(group_a_methods.first)).to eq true
+    end
+
+    it "should call top-level methods directly" do
+      method_name = group_a_methods.first
+      expect(obja.send(method_name)).to eq("In #{obja.class.name}##{method_name}")
+    end
+
+    it "should 'respond_to?' 2nd-level methods" do
+      expect(obja.respond_to?(group_a_methods.first)).to eq true
+      expect(obja.respond_to?(group_b_methods.first)).to eq false
+
+      obja.delegate = objb
+      expect(obja.respond_to?(group_b_methods.first)).to eq true
+    end
+
+    it "should call 2nd-level methods" do
+      method_a_name = group_a_methods.first
+      method_b_name = group_b_methods.first
+
+      expect(obja.send(method_a_name)).to eq("In #{obja.class.name}##{method_a_name}")
+
+      expect do
+        obja.send(method_b_name)
+      end.to raise_exception(NoMethodError, /undefined method `#{method_b_name}' for.*/)
+
+      obja.delegate = objb
+      expect(obja.send(method_b_name)).to eq("In #{objb.class.name}##{method_b_name}")
+    end
+
+    it "should 'respond_to?' 3rd-level methods" do
+      expect(obja.respond_to?(group_a_methods.first)).to eq true
+      expect(obja.respond_to?(group_b_methods.first)).to eq false
+      expect(obja.respond_to?(group_c_methods.first)).to eq false
+
+      obja.delegate = objb
+      expect(obja.respond_to?(group_b_methods.first)).to eq true
+      expect(obja.respond_to?(group_c_methods.first)).to eq false
+
+      objb.delegate = objc
+      expect(obja.respond_to?(group_c_methods.first)).to eq true
+    end
+
+    it "should call 3rd-level methods" do
+      method_a_name = group_a_methods.first
+      method_b_name = group_b_methods.first
+      method_c_name = group_c_methods.first
+
+      expect(obja.send(method_a_name)).to eq("In #{obja.class.name}##{method_a_name}")
+
+      expect do
+        obja.send(method_b_name)
+      end.to raise_exception(NoMethodError, /undefined method `#{method_b_name}' for.*/)
+
+      expect do
+        obja.send(method_c_name)
+      end.to raise_exception(NoMethodError, /undefined method `#{method_c_name}' for.*/)
+
+      obja.delegate = objb
+      expect(obja.send(method_b_name)).to eq("In #{objb.class.name}##{method_b_name}")
+
+      expect do
+        obja.send(method_c_name)
+      end.to raise_exception(NoMethodError, /undefined method `#{method_c_name}' for.*/)
+
+      objb.delegate = objc
+      expect(obja.send(method_c_name)).to eq("In #{objc.class.name}##{method_c_name}")
+    end
+  end
+end

data/spec/gpt_partition_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+require "partition_shared_examples"
+
+describe "GPT Partition" do
+  let(:extpected_num_partitions) { 3 }
+  let(:expected_partition_class) { VirtDisk::PartitionType::GptPartition }
+
+  let(:per_partition_values) do
+    [
+      {
+        :ptype           =>  "af3dc60f-8384-7247-8e79-3d69d8477de4",
+        :block_size      => 512,
+        :start_lba       => 34,
+        :end_lba         => 512,
+        :start_byte_addr => 17408,
+        :end_byte_addr   => 262144,
+        :size            => 244736
+      },
+      {
+        :ptype           => "af3dc60f-8384-7247-8e79-3d69d8477de4",
+        :block_size      => 512,
+        :start_lba       => 513,
+        :end_lba         => 1024,
+        :start_byte_addr => 262656,
+        :end_byte_addr   => 524288,
+        :size            => 261632
+      },
+      {
+        :ptype           => "af3dc60f-8384-7247-8e79-3d69d8477de4",
+        :block_size      => 512,
+        :start_lba       => 1025,
+        :end_lba         => 2014,
+        :start_byte_addr => 524800,
+        :end_byte_addr   => 1031168,
+        :size            => 506368
+      }
+    ]
+  end
+
+  data_dir = File.join(__dir__, "data")
+  dos_partition_file = File.join(data_dir, "gpt_partition.img")
+  file_mod = VirtDisk::FileIo.new(dos_partition_file)
+  disk = VirtDisk::Disk.new(file_mod)
+
+  it "should return an array of the expected length" do
+    expect(VirtDisk::PartitionType.partition_probe(disk).length).to eq(extpected_num_partitions)
+  end
+
+  VirtDisk::PartitionType.partition_probe(disk).each do |part|
+    describe "Partition: #{part.pnum}" do
+      before(:each) do
+        @partition = part
+      end
+
+      it_should_behave_like "common_partition"
+    end
+  end
+end