ruby-lvm 0.0.1 → 0.1.1

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,37 @@
+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.each do |pvseg|
+          if pvseg.pv_uuid == pv.uuid 
+            pv.segments << pvseg
+          end
+        end
+      end
+
+      return pvs.each {|p| yield p}
+    end
+  end
+
+end

data/lib/lvm/userland.rb

@@ -0,0 +1,5 @@
+require 'ostruct'
+
+module LVM
+  class UserLand < OpenStruct; end
+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,46 @@
+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
+      
+      vgs.each do |vg|
+        vg.logical_volumes ||= []
+        @lvs.each do |lv|
+          if lv.vg_uuid == vg.uuid
+            vg.logical_volumes << lv
+          end
+        end
+        vg.physical_volumes ||= []
+        @pvs.each do |pv|
+          if pv.vg_uuid == vg.uuid
+            vg.physical_volumes << pv
+          end
+        end
+      end
+
+      return vgs.each {|v| yield v}
+    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.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/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 
+
+