otakumike-ruby-lvm 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 364fa0210d78fe3efb61f86287b05c87ad52126c
+  data.tar.gz: 3bf6344d02f0cfa8ae09bce3b2517b6c6feb975a
+SHA512:
+  metadata.gz: 4bdfd0b5a9bb0b373009733ad5cb34b7ddcc8a171f8f883dfe22c8af1e82aeb2ded4ba3978fd9e2ea7de40364aa14bc7b8fd44c64bf7eca6c96672a9379580f6
+  data.tar.gz: 306d3426dda73bd978320cd77a86eda36a42e31474d00cab6ee05cc8abfa9344e42b8e9cac8e25f716defaea115029d510ed59b5546fe3ebcbbed2e2e7dc9f32

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/History.txt

@@ -0,0 +1,14 @@
+=== 0.1.1 / 2008-07-21
+
+* 1 major enhancement
+  * A complete rewrite! We won't bother attempting to wrap complex lvm
+    operations, but instead provide LVM.raw() command. The wrapper now focuses
+    purely on translating lvm lv/vg/pv data into the most useful ruby objects
+    possible. The arguments passed to the underlying binaries have been broken
+    out into a ruby-lvm-attributes package.
+
+=== 0.0.1 / 2008-05-28
+
+* 1 major enhancement
+  * Birthday!
+  * Test release.

data/README.txt

@@ -0,0 +1,77 @@
+= ruby-lvm
+
+* http://ruby-lvm.rubyforge.org
+* mailto:mkent@magoazul.com
+
+== DESCRIPTION:
+This is a fork of the ruby-lvm gem found at git://rubyforge.org/ruby-lvm.git.
+The primary difference from upstream is that it depends on
+di-ruby-lvm-attributes instead of ruby-lvm-attributes. This adds support for lvm
+version 2.02.66(2).
+
+
+This is a wrapper for the LVM2 administration utility, lvm. Its primary
+function it to convert physical volumes, logical volumes and volume groups
+into easy to use ruby objects. It also provides a simple wrapper for typical
+create/delete/etc operations.
+
+Due to a lack of LVM2 api this is a best effort attempt at ruby integration but
+subject to complete replacement in the future.
+
+== FEATURES/PROBLEMS:
+
+* Exposes all possible data from the lvs/vgs/pvs commands. Data is grouped
+  sensibly (I hope).
+* Doesn't nicely wrap creation/deletion/etc operations, they must be created
+  by hand and passed as raw commands.
+
+== SYNOPSIS:
+
+  require 'lvm'
+
+  LVM::LVM.new({:command => "/usr/bin/sudo /sbin/lvm"}) do |lvm|
+    puts "lvm version: #{lvm.version}\n"
+
+    lvm.volume_groups.each do |vg|
+      puts "vg: #{vg.name}"
+    end
+  end
+
+== REQUIREMENTS:
+
+* di-ruby-lvm-attributes
+* popen4 
+
+== INSTALL:
+
+* sudo gem install di-ruby-lvm 
+
+== FEEDBACK:
+
+Please feel free to submit patches or constructive criticism, I'm still pretty
+new to ruby and object oriented programming in general.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Matthew Kent, Bravenet Web Services Inc. 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Todo.txt

@@ -0,0 +1,9 @@
+= to do
+
+== 0.2.1
+* basic test suite, how?
+
+== 0.1.2
+* test on more distributions!
+* more documentation.
+* debug mode, logger?

data/examples/create_snapshot.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby
+
+# Demonstration of the creation of an lvm snapshot, using sudo, and reading its
+# attributes.
+
+$: << File.dirname(__FILE__) + "/../lib"
+
+require 'lvm'
+
+vol = "sys.vg/tmp.lv"
+snap = "demo_snap"
+
+lvm = LVM::LVM.new(:command => "/usr/bin/sudo /sbin/lvm")
+
+if lvm.logical_volumes[snap]
+  puts "#{snap} exists! Remove it"
+  exit(1)
+end
+
+lvm.raw("lvcreate --snapshot --size 10M --name #{snap} #{vol}")
+lv = lvm.logical_volumes[snap]
+
+out=<<msg
+snapshot of #{vol}, #{snap}, created
+- uuid: #{lv.uuid}
+- major,minor: #{lv.kernel_major},#{lv.kernel_minor}
+msg
+puts out

data/examples/error_handling.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+
+# Demonstration of the exception handling with raw commands. 
+
+$: << File.dirname(__FILE__) + "/../lib"
+
+require 'lvm'
+
+lvm = LVM::LVM.new(:command => "/usr/bin/sudo /sbin/lvm")
+
+begin 
+  lvm.raw("--blah blah")
+rescue LVM::External::ExternalFailure => error 
+  puts "Raw operation failed with [#{error}]"
+end

data/examples/show_lvm_config.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+
+# A more advanced demonstration displaying a complete overview of the current
+# lvm configuration.
+
+$: << File.dirname(__FILE__) + "/../lib"
+
+require 'lvm'
+
+LVM::LVM.new({:command => "/usr/bin/sudo /sbin/lvm"}) do |lvm|
+  puts "lvm version: #{lvm.version}\n"
+  
+  puts "\nlogical view"
+  puts "------------"
+  lvm.volume_groups.each do |vg|
+    puts "vg: #{vg.name}"
+    vg.logical_volumes.each do |lv|
+      puts "  lv: #{lv.name} #{lv.size}"
+      lv.segments.each do |lvseg|
+        puts "    lvseg: #{lvseg.devices} ##{lv.segments.index(lvseg)} #{lvseg.start} - #{lvseg.finish} = #{lvseg.size}"
+      end
+      if lv.snapshot?
+        puts "    snapshot origin: #{lv.origin}"
+      end
+    end
+  end
+  
+  puts "\nphysical view"
+  puts   "-------------"
+  lvm.volume_groups.each do |vg|
+    puts "vg: #{vg.name}"
+    vg.physical_volumes.each do |pv|
+      puts "  pv: #{pv.name}"
+      pv.segments.each do |pvseg|
+        puts "    pvseg: ##{pv.segments.index(pvseg)} #{pvseg.start} - #{pvseg.finish}"
+      end
+    end
+  end
+
+end

data/lib/lvm/external.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'open4'
+
+module LVM
+  module External
+    class ExternalFailure < RuntimeError; end 
+
+    def cmd(cmd)
+      output = []
+      error = nil
+      stat = Open4.popen4(cmd) do |pid, stdin, stdout, stderr|
+        while line = stdout.gets
+          output << line 
+        end
+        error = stderr.read.strip
+      end
+      if stat.exited?
+        if stat.exitstatus > 0
+          raise ExternalFailure, "Fatal error, `#{cmd}` returned #{stat.exitstatus} with '#{error}'"
+        end
+      elsif stat.signaled?
+        raise ExternalFailure, "Fatal error, `#{cmd}` got signal #{stat.termsig} and terminated"
+      elsif stat.stopped?
+        raise ExternalFailure, "Fatal error, `#{cmd}` got signal #{stat.stopsig} and is stopped"
+      end
+
+      if block_given?
+        return output.each { |l| yield l }
+      else 
+        return output.join
+      end
+    end
+    module_function :cmd
+
+  end # module External 
+end # module LVM 

data/lib/lvm/logical_volume.rb

@@ -0,0 +1,9 @@
+require 'ostruct'
+
+module LVM
+  class LogicalVolume < OpenStruct
+    # Helpers
+    def open?; device_open; end
+    def snapshot?; volume_type == :snapshot ? true : false; end
+  end
+end

data/lib/lvm/logical_volume_segment.rb

@@ -0,0 +1,5 @@
+require 'ostruct'
+
+module LVM
+  class LogicalVolumeSegment < OpenStruct; end
+end

data/lib/lvm/logical_volumes.rb

@@ -0,0 +1,34 @@
+require 'lvm/volumes'
+require 'lvm/wrapper/lvs'
+require 'lvm/wrapper/lvsseg'
+
+module LVM
+  class LogicalVolumes
+    include Enumerable
+
+    include Volumes
+    include Wrapper
+
+    def initialize(options)
+      @lvs = LVS.new(options)
+      @lvsseg = LVSSEG.new(options)
+    end
+
+    # Gather all information about logical volumes.
+    #
+    # See VolumeGroups.each for a better representation of LVM data.
+    def each 
+      lvs = @lvs.list
+      lvsseg = @lvsseg.list 
+
+      lvs.each do |lv|
+        lv.segments = lvsseg.select { |seg| seg.lv_uuid == lv.uuid }
+        yield lv
+      end          
+    end
+
+    def list
+      self.each { }
+    end
+  end
+end

data/lib/lvm/physical_volume.rb

@@ -0,0 +1,5 @@
+require 'ostruct'
+
+module LVM
+  class PhysicalVolume < OpenStruct; end
+end

data/lib/lvm/physical_volume_segment.rb

@@ -0,0 +1,5 @@
+require 'ostruct'
+
+module LVM
+  class PhysicalVolumeSegment < OpenStruct; end
+end

data/lib/lvm/physical_volumes.rb

@@ -0,0 +1,34 @@
+require 'lvm/volumes'
+require 'lvm/wrapper/pvs'
+require 'lvm/wrapper/pvsseg'
+
+module LVM
+  class PhysicalVolumes
+    include Enumerable
+
+    include Volumes
+    include Wrapper
+
+    def initialize(options)
+      @pvs = PVS.new(options)
+      @pvsseg = PVSSEG.new(options)
+    end
+
+    # Gather all information about physical volumes.
+    #
+    # See VolumeGroups.each for a better representation of LVM data.
+    def each 
+      pvs = @pvs.list
+      pvsseg = @pvsseg.list 
+
+      pvs.each do |pv|
+        pv.segments = pvsseg.select { |seg| seg.pv_uuid == pv.uuid }
+        yield pv
+      end
+    end
+
+    def list
+      self.each { }
+    end
+  end
+end

data/lib/lvm/userland.rb

@@ -0,0 +1,5 @@
+require 'ostruct'
+
+module LVM
+  class UserLand < OpenStruct; end
+end

data/lib/lvm/version.rb

@@ -0,0 +1,3 @@
+module LVM
+  VERSION = '0.2.1'
+end

data/lib/lvm/volume_group.rb

@@ -0,0 +1,5 @@
+require 'ostruct'
+
+module LVM
+  class VolumeGroup < OpenStruct; end
+end

data/lib/lvm/volume_groups.rb

@@ -0,0 +1,39 @@
+require 'lvm/volumes'
+require 'lvm/logical_volumes'
+require 'lvm/physical_volumes'
+require 'lvm/wrapper/vgs'
+
+module LVM
+  class VolumeGroups 
+    include Enumerable
+
+    include Volumes
+    include Wrapper
+
+    def initialize(options)
+      @vgs = VGS.new(options)
+      @pvs = PhysicalVolumes.new(options)
+      @lvs = LogicalVolumes.new(options)
+    end
+
+    # Gather all information about volume groups and their underlying
+    # logical and physical volumes. 
+    #
+    # This is the best representation of LVM data.
+    def each 
+      vgs = @vgs.list
+      lvs = @lvs.list
+      pvs = @pvs.list
+      
+      vgs.each do |vg|
+        vg.logical_volumes  = lvs.select { |lv| lv.vg_uuid == vg.uuid }
+        vg.physical_volumes = pvs.select { |pv| pv.vg_uuid == vg.uuid }
+        yield vg
+      end
+    end
+
+    def list
+      self.each { }
+    end
+ end
+end

data/lib/lvm/volumes.rb

@@ -0,0 +1,16 @@
+module LVM
+  module Volumes
+
+    def [](name)
+      each {|o| return o if o.name == name}
+      return nil
+    end
+
+    def to_s
+      x = []
+      each {|o| x << o.name}
+      return x.join(" ")
+    end
+
+  end
+end

data/lib/lvm/wrapper/constants.rb

@@ -0,0 +1,11 @@
+module LVM
+  module Wrapper
+    module Reporting 
+      module Constants
+        SEPERATOR = '^'
+        BASE_ARGUMENTS = "--verbose --separator=#{SEPERATOR} --noheadings --nosuffix --units=b --unbuffered --options %s"
+        EMPTY = '-'
+      end
+    end
+  end
+end

data/lib/lvm/wrapper/lvs.rb

@@ -0,0 +1,127 @@
+require 'lvm/wrapper'
+require 'lvm/logical_volume'
+
+module LVM
+  module Wrapper
+    class LVS
+      include Reporting
+
+      attr_reader :attributes
+      attr_reader :command
+
+      def initialize(options)
+        @attributes = Attributes.load(options[:version], ATTRIBUTES_FILE)
+        @command = "#{options[:command]} #{Reporting.build_command(attributes, BASE_COMMAND)}"
+      end
+
+      BASE_COMMAND = "lvs #{Reporting::BASE_ARGUMENTS}"
+      ATTRIBUTES_FILE = 'lvs.yaml'
+  
+      # lv_attr attribute handling constants
+      # roughly by order referenced in lib/report/report.c:292 (_lvstatus_disp)
+      #
+      VOLUME_TYPE = {
+        'p' => :pvmove,
+        'c' => :conversion,
+        'M' => :mirror_not_synced,
+        'm' => :mirror,
+        'i' => :mirror_image,
+        'I' => :mirror_image_not_synced,
+        'l' => :mirror_log,
+        'v' => :virtual,
+        'o' => :origin,
+        's' => :snapshot,
+        'S' => :invalid_snapshot,
+        # custom, empty is a standard volume
+        '-' => :normal
+      }
+      PERMISSIONS = {
+        'w' => :writeable,
+        'r' => :readonly,
+        # custom, from reading source
+        '-' => :locked_by_pvmove,
+      }
+      ALLOCATION_POLICY = {
+        'c' => :contiguous,
+        'l' => :cling,
+        'n' => :normal,
+        'a' => :anywhere,
+        'i' => :inherited,
+        'C' => :contiguous_locked,
+        'L' => :cling_locked,
+        'N' => :normal_locked,
+        'A' => :anywhere_locked,
+        'I' => :inherited_locked
+      }
+      FIXED_MINOR = {
+        # code says its a boolean
+        'm' => true
+      }
+      STATE = {
+        's' => :suspended,
+        'a' => :active,
+        'i' => :inactive_with_table,
+        'd' => :inactive_without_table,
+        'S' => :suspended_snapshot,
+        'I' => :invalid_snapshot
+      } 
+      DEVICE_OPEN = {
+        # code says its a boolean
+        'o' => true 
+      }
+
+      def list
+        output = External.cmd(@command)
+        data = parse(output)
+        if block_given?
+          return data.each { |obj| yield obj }
+        else
+          return data
+        end
+      end
+
+      private
+
+        def parse_lv_attr(lv_attr) #:nodoc:
+          translated = {}
+          # translate them into nice symbols and a couple booleans 
+          translated[:volume_type] = VOLUME_TYPE[lv_attr[0].chr]
+          translated[:permissions] = PERMISSIONS[lv_attr[1].chr]
+          translated[:allocation_policy] = ALLOCATION_POLICY[lv_attr[2].chr]
+          translated[:fixed_minor] = FIXED_MINOR[lv_attr[3].chr] ? true : false
+          translated[:state] = STATE[lv_attr[4].chr]
+          translated[:device_open] = DEVICE_OPEN[lv_attr[5].chr] ? true : false
+
+          return translated
+        end
+  
+        # Parses the output of self.command
+        def parse(output) #:nodoc:
+          volumes = []
+ 
+          output.split("\n").each do |line|
+            args = Reporting.process_line(attributes, line)
+
+            # now we force some types to ints since we've requested them as bytes
+            # without a suffix
+            args[:size] = args[:size].to_i
+  
+            # we resolve the attributes line to nicer symbols
+            args.merge!(parse_lv_attr(args[:attr]))
+
+            # finally build our object
+            volume = LogicalVolume.new(args)
+  
+            if block_given?
+              yield volume
+            else
+              volumes << volume
+            end
+          end
+    
+          return volumes
+        end # parse
+ 
+    end # class LVS
+  end # module Wrapper
+end # module LVM

data/lib/lvm/wrapper/lvsseg.rb

@@ -0,0 +1,59 @@
+require 'lvm/wrapper'
+require 'lvm/logical_volume_segment'
+
+module LVM
+  module Wrapper
+    # segment output is very different in that its multi line, easier to treat as own command
+    class LVSSEG
+      include Reporting
+
+      attr_reader :attributes
+      attr_reader :command
+
+      def initialize(options)
+        @attributes = Attributes.load(options[:version], ATTRIBUTES_FILE)
+        @command = "#{options[:command]} #{Reporting.build_command(attributes, BASE_COMMAND)}"
+      end
+
+      BASE_COMMAND = "lvs #{Reporting::BASE_ARGUMENTS}"
+      ATTRIBUTES_FILE = 'lvsseg.yaml'
+
+      def list
+        output = External.cmd(@command)
+        data = parse(output)
+        if block_given?
+          return data.each { |obj| yield obj }
+        else
+          return data
+        end
+      end
+  
+      private
+
+        # Parses the output of self.command
+        def parse(output)
+          volumes = []
+
+          output.split("\n").each do |line|
+            args = process_line(attributes, line)
+
+            args[:finish] = args[:start] + args[:size]
+
+            # finally build our object
+            volume = LogicalVolumeSegment.new(args)
+
+            if block_given?
+              yield volume
+            else
+              volumes << volume
+            end
+          end
+  
+          return volumes
+        end # parse
+        
+    end # class LVSSEG 
+  end # module Wrapper
+end # module LVM 
+
+

data/lib/lvm/wrapper/pvs.rb

@@ -0,0 +1,84 @@
+require 'lvm/wrapper'
+require 'lvm/physical_volume'
+
+module LVM
+    module Wrapper
+      class PVS
+        include Reporting
+
+        attr_reader :attributes
+        attr_reader :command
+
+        def initialize(options)
+          @attributes = Attributes.load(options[:version], ATTRIBUTES_FILE)
+          @command = "#{options[:command]} #{Reporting.build_command(attributes, BASE_COMMAND)}"
+        end
+
+        BASE_COMMAND = "pvs #{Reporting::BASE_ARGUMENTS}"
+        ATTRIBUTES_FILE = 'pvs.yaml'
+    
+        # pv_attr attribute handling constants
+        # roughly by order referenced in lib/report/report.c:360 (_pvstatus_disp)
+        #
+        ALLOCATABLE = {
+          # code says its a boolean
+          'a' => true 
+        }
+        EXPORTED = {
+          # code says its a boolean
+          'x' => true
+        }
+
+        def list
+          output = External.cmd(@command)
+          data = parse(output)
+          if block_given?
+            return data.each { |obj| yield obj }
+          else
+            return data
+          end
+        end
+
+        private
+
+          def parse_pv_attr(pv_attr) #:nodoc:
+            translated = {}
+            # translate them into nice symbols and a couple booleans 
+            translated[:allocatable] = ALLOCATABLE[pv_attr[0].chr] ? true : false
+            translated[:exported] = EXPORTED[pv_attr[1].chr] ? true : false
+
+            return translated 
+          end
+
+          # Parses the output of self.command
+          def parse(output)
+            volumes = []
+
+            output.split("\n").each do |line|
+              args = process_line(attributes, line)
+
+              # now we force some types to ints since we've requested them as bytes
+              # without a suffix
+              args[:size] = args[:size].to_i
+
+              # we resolve the attributes line to nicer symbols
+              args.merge!(parse_pv_attr(args[:attr]))
+
+              # finally build our object
+              volume = PhysicalVolume.new(args)
+
+              if block_given?
+                yield volume
+              else
+                volumes << volume
+              end
+            end
+  
+            return volumes
+          end # parse
+          
+      end # class PVS
+    end # module Wrapper
+end # module LVM 
+
+

data/lib/lvm/wrapper/pvsseg.rb

@@ -0,0 +1,57 @@
+require 'lvm/wrapper'
+require 'lvm/physical_volume_segment'
+
+module LVM
+  module Wrapper
+    # segment output is very different in that its multi line, easier to treat as own command
+    class PVSSEG
+      include Reporting
+
+      attr_reader :attributes
+      attr_reader :command
+
+      def initialize(options)
+        @attributes = Attributes.load(options[:version], ATTRIBUTES_FILE)
+        @command = "#{options[:command]} #{Reporting.build_command(attributes, BASE_COMMAND)}"
+      end
+
+      BASE_COMMAND = "pvs #{Reporting::BASE_ARGUMENTS}"
+      ATTRIBUTES_FILE = 'pvsseg.yaml'
+ 
+      def list
+        output = External.cmd(@command)
+        data = parse(output)
+        if block_given?
+          return data.each { |obj| yield obj }
+        else
+          return data
+        end
+      end
+ 
+      private
+
+        # Parses the output of self.command
+        def parse(output)
+          volumes = []
+
+          output.split("\n").each do |line|
+            args = process_line(attributes, line)
+
+            args[:finish] = args[:start] + args[:size]
+
+            # finally build our object
+            volume = PhysicalVolumeSegment.new(args)
+
+            if block_given?
+              yield volume
+            else
+              volumes << volume
+            end
+          end
+  
+          return volumes
+        end # parse
+        
+    end # class PVSSEG
+  end # module Wrapper
+end # module LVM 

data/lib/lvm/wrapper/vgs.rb

@@ -0,0 +1,112 @@
+require 'lvm/wrapper'
+require 'lvm/volume_group'
+
+module LVM
+  module Wrapper
+    class VGS
+      include Reporting
+
+      attr_reader :attributes
+      attr_reader :command
+
+      def initialize(options)
+        @attributes = Attributes.load(options[:version], ATTRIBUTES_FILE)
+        @command = "#{options[:command]} #{Reporting.build_command(attributes, BASE_COMMAND)}"
+      end
+
+      BASE_COMMAND = "vgs #{Reporting::BASE_ARGUMENTS}"
+      ATTRIBUTES_FILE = 'vgs.yaml'
+  
+      # vg_attr attribute handling constants
+      # roughly by order referenced in lib/report/report.c:360 (_vgstatus_disp)
+      #
+      PERMISSIONS = {
+        'w' => :writeable,
+        'r' => :readonly,
+      }
+      RESIZEABLE = {
+        # code says its a boolean
+        'z' => true 
+      }
+      EXPORTED = {
+        # code says its a boolean
+        'x' => true
+      }
+      PARTIAL = {
+        # code says its a boolean
+        'p' => true
+      }
+      ALLOCATION_POLICY = {
+        'c' => :contiguous,
+        'l' => :cling,
+        'n' => :normal,
+        'a' => :anywhere,
+        'i' => :inherited,
+        'C' => :contiguous_locked,
+        'L' => :cling_locked,
+        'N' => :normal_locked,
+        'A' => :anywhere_locked,
+        'I' => :inherited_locked
+      }
+      CLUSTERED = {
+        # code says its a boolean
+        'c' => true
+      }
+
+      def list
+        output = External.cmd(@command)
+        data = parse(output)
+        if block_given?
+          return data.each { |obj| yield obj }
+        else
+          return data
+        end
+      end
+
+      private
+
+        def parse_vg_attr(vg_attr) #:nodoc:
+          translated = {}
+          # translate them into nice symbols and a couple booleans 
+          translated[:permissions] = PERMISSIONS[vg_attr[0].chr]
+          translated[:resizeable] = RESIZEABLE[vg_attr[1].chr] ? true : false
+          translated[:exported] = EXPORTED[vg_attr[2].chr] ? true : false
+          translated[:partial] = PARTIAL[vg_attr[3].chr] ? true : false
+          translated[:allocation_policy] = ALLOCATION_POLICY[vg_attr[4].chr]
+          translated[:clustered] = CLUSTERED[vg_attr[5].chr] ? true : false
+
+          return translated
+       end
+  
+        # Parses the output of self.command
+        def parse(output) #:nodoc:
+          volumes = []
+ 
+          output.split("\n").each do |line|
+            args = process_line(attributes, line)
+
+            # now we force some types to ints since we've requested them as bytes
+            # without a suffix
+            args[:size] = args[:size].to_i
+  
+            # we resolve the attributes line to nicer symbols
+            args.merge!(parse_vg_attr(args[:attr]))
+
+            # finally build our object
+            volume = VolumeGroup.new(args)
+  
+            if block_given?
+              yield volume
+            else
+              volumes << volume
+            end
+          end
+    
+          return volumes
+        end # parse
+
+    end # class VGS
+  end # module Wrapper
+end # module LVM
+
+

data/lib/lvm/wrapper.rb

@@ -0,0 +1,53 @@
+require 'lvm/attributes'
+require 'lvm/external'
+require 'lvm/wrapper/constants'
+
+module LVM
+  module Wrapper
+    module Reporting 
+      include Constants
+
+      # Breakdown return values into attribute => value hash suitable for
+      # OpenStruct
+      def process_line(expected_attributes, line) #:nodoc:
+        line.strip!
+        values = line.split(SEPERATOR)
+        # nil is easier
+        values.map! { |v| (v.empty?) ? nil : v }
+        
+        attributes = {}
+        # values and expected attributes are in the same order
+        values.size.times do |i|
+          value  = values[i]
+          attribute = expected_attributes[i]
+
+          name = attribute[:method].to_sym
+
+          # use hints for type conversion
+          case attribute[:type_hint] 
+          when "String"
+          when "Integer"
+            value = value.to_i
+          when "Float"
+            value = value.to_f
+          end
+          attributes[name] = value
+        end
+
+        return attributes
+      end
+      module_function :process_line
+
+      def build_command(expected_attributes, base)
+        opts = []
+        expected_attributes.each do |a|
+          opts << a[:column]
+        end
+        
+        return base % opts.join(",")
+      end
+      module_function :build_command
+
+    end # module Reporting 
+  end # module Wrapper
+end # module LVM

data/lib/lvm.rb

@@ -0,0 +1,81 @@
+require 'lvm/external'
+require 'lvm/userland'
+require 'lvm/logical_volumes'
+require 'lvm/volume_groups'
+require 'lvm/physical_volumes'
+require 'lvm/version'
+
+module LVM
+  class LVM
+    attr_reader :command
+    attr_reader :logical_volumes
+    attr_reader :volume_groups
+    attr_reader :physical_volumes
+
+    VALID_OPTIONS = [
+      :command,
+      :version,
+      :debug
+    ]
+
+    DEFAULT_COMMAND = '/sbin/lvm'
+
+    def initialize(options={})
+      # handy, thanks net-ssh!
+      invalid_options = options.keys - VALID_OPTIONS
+      if invalid_options.any?
+        raise ArgumentError, "invalid option(s): #{invalid_options.join(', ')}"
+      end
+
+      @command = options[:command] || DEFAULT_COMMAND
+
+      # default to loading attributes for the current version
+      options[:version] ||= version 
+      options[:debug] ||= false
+
+      @logical_volumes = LogicalVolumes.new(options)
+      @volume_groups = VolumeGroups.new(options)
+      @physical_volumes = PhysicalVolumes.new(options)
+
+      if block_given?
+        yield self
+      else
+        return self
+      end
+    end
+
+    def raw(args)
+      output = []
+      External.cmd("#{@command} #{args}") do |line|
+        output << line
+      end
+      if block_given?
+        return output.each { |l| yield l }
+      else
+        return output.join
+      end
+    end
+
+    def version
+      %r{^(.*?)(-| )}.match(userland.lvm_version)[1]
+    end
+
+    # helper methods
+    def userland
+      userland = UserLand.new
+      raw('version') do |line|
+        case line
+        when  %r{^\s+LVM version:\s+([0-9].*)$}
+          userland.lvm_version = $1
+        when %r{^\s+Library version:\s+([0-9].*)$}
+          userland.library_version = $1
+        when  %r{^\s+Driver version:\s+([0-9].*)$}
+          userland.driver_version = $1
+        end
+      end
+
+      return userland
+    end
+
+  end
+end

data/otakumike-ruby-lvm.gemspec

@@ -0,0 +1,26 @@
+$:.unshift(File.expand_path('../lib/', __FILE__))
+require 'lvm/version'
+
+deps = {
+  'open4' => [ '~> 0.9', '>= 0.9.6' ],
+  'otakumike-ruby-lvm-attrib' => ['~> 0.0.3']
+}
+
+Gem::Specification.new do |gem|  
+  gem.authors       = ["Greg Symons", "Matthew Kent", "Mike Richardson"]  
+  gem.email         = ["mkent@magoazul.com", 'gsymons@gsconsulting.biz', 'mail@mikerichardson.com.au']  
+  gem.description   = %q{A wrapper for the LVM2 administration utility, lvm. Forked for LVM 2.02.166 ONLY}
+  gem.license       = "MIT"
+  gem.summary       = %q{A wrapper for the LVM2 administration utility, lvm. Forked for LVM 2.02.166 ONLY}
+  gem.homepage      = "https://github.com/otakumike/otakumike-ruby-lvm"
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "otakumike-ruby-lvm"
+  gem.require_paths = ["lib"]
+  gem.version       = LVM::VERSION
+
+  deps.each do |dep, constraints|
+    gem.add_runtime_dependency dep, *constraints
+  end
+end
+

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: otakumike-ruby-lvm
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Greg Symons
+- Matthew Kent
+- Mike Richardson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: open4
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+- !ruby/object:Gem::Dependency
+  name: otakumike-ruby-lvm-attrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+description: A wrapper for the LVM2 administration utility, lvm. Forked for LVM 2.02.166
+  ONLY
+email:
+- mkent@magoazul.com
+- gsymons@gsconsulting.biz
+- mail@mikerichardson.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- History.txt
+- README.txt
+- Todo.txt
+- examples/create_snapshot.rb
+- examples/error_handling.rb
+- examples/show_lvm_config.rb
+- lib/lvm.rb
+- lib/lvm/external.rb
+- lib/lvm/logical_volume.rb
+- lib/lvm/logical_volume_segment.rb
+- lib/lvm/logical_volumes.rb
+- lib/lvm/physical_volume.rb
+- lib/lvm/physical_volume_segment.rb
+- lib/lvm/physical_volumes.rb
+- lib/lvm/userland.rb
+- lib/lvm/version.rb
+- lib/lvm/volume_group.rb
+- lib/lvm/volume_groups.rb
+- lib/lvm/volumes.rb
+- lib/lvm/wrapper.rb
+- lib/lvm/wrapper/constants.rb
+- lib/lvm/wrapper/lvs.rb
+- lib/lvm/wrapper/lvsseg.rb
+- lib/lvm/wrapper/pvs.rb
+- lib/lvm/wrapper/pvsseg.rb
+- lib/lvm/wrapper/vgs.rb
+- otakumike-ruby-lvm.gemspec
+- test/test_lvm.rb
+homepage: https://github.com/otakumike/otakumike-ruby-lvm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A wrapper for the LVM2 administration utility, lvm. Forked for LVM 2.02.166
+  ONLY
+test_files:
+- test/test_lvm.rb