ruby-lvm 0.0.1

data/lib/lvm/lvs.rb

@@ -0,0 +1,143 @@
+module LVMWrapper
+  class LVS
+    require 'yaml'
+
+    BASE_COMMAND = 'lvs --verbose --separator=, --noheadings --nosuffix --units=b --unbuffered --options %s'
+    #,vg_uuid' 
+    ATTRIBUTES = 'attrib/lvs.yaml'
+
+    EMPTY = '-'
+
+    # 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 self.command
+      opts = []
+      attributes = YAML.load_file(File.dirname(__FILE__) + '/' + ATTRIBUTES)
+      attributes.each do |a|
+        opts << a[:option]
+      end
+      
+      BASE_COMMAND % opts.join(",")
+    end
+
+    def self.parse_lv_attr(lv_attr)
+        ret = {}
+        # translate them into nice symbols and a couple booleans 
+        ret[:volume_type] = VOLUME_TYPE[lv_attr[0].chr]
+        ret[:permissions] = PERMISSIONS[lv_attr[1].chr]
+        ret[:allocation_policy] = ALLOCATION_POLICY[lv_attr[2].chr]
+        ret[:fixed_minor] = FIXED_MINOR[lv_attr[3].chr] ? true : false
+        ret[:state] = STATE[lv_attr[4].chr]
+        ret[:device_open] = DEVICE_OPEN[lv_attr[5].chr] ? true : false
+        ret
+    end
+
+    # Parses the output of self.command
+    def self.parse(output)
+      volumes = []
+
+      # lvs columns will become lv attributes
+      attributes = YAML.load_file(File.dirname(__FILE__) + '/' + ATTRIBUTES)
+  
+      output.split("\n").each do |line|
+        line.strip!
+        # each line of output is comma separated values
+        values = line.split(",")
+        # empty values to nil
+        values.map! do |value|
+          if value.empty?
+            nil
+          else
+            value
+          end
+        end
+        
+        args = {}
+        # match up attribute => value
+        values.size.times do |i|
+          method = attributes[i][:method].to_sym
+          value  = values[i]
+          # use our hints first for type conversion
+          if attributes[i][:type_hint] == "Integer"
+            value = value.to_i
+          elsif attributes[i][:type_hint] == "Float"
+            value = value.to_f
+          end
+          args[method] = value
+        end
+
+        # LVSEG
+
+        # 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
+  
+      volumes
+    end # parse
+  
+  end # class
+end # module 

data/lib/lvm/lvseg.rb

@@ -0,0 +1,14 @@
+module LVMWrapper
+  class PhysicalVolumeSegment
+    attr_reader :start, :size, :finish
+
+    def initialize(args)
+        @start = args[:start]
+        @size = args[:size]
+
+        @finish = @start + @size
+    end
+
+    # helper methods
+  end # class
+end # module

data/lib/lvm/proc.rb

@@ -0,0 +1,39 @@
+module LVMWrapper 
+  class External
+    class ExternalFailure < RuntimeError; end 
+
+    # Class Methods
+    #
+    class<<self
+      # Return output of external command
+      # Yield each line or return entire output
+      #
+      def cmd(cmd)
+        output = []
+        IO.popen(cmd, "r") do |p|
+          while line = p.gets
+            if defined? yield 
+              yield line
+            else
+              output << line 
+            end
+          end
+        end
+        stat = $?
+        if stat.exited?
+          if stat.exitstatus > 0
+            raise ExternalFailure, "Fatal error, `#{cmd}` returned #{stat.exitstatus}"
+          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
+        output.join
+      end
+    end
+
+    # Instance Methods
+    #
+  end # class
+end # module

data/lib/lvm/pv.rb

@@ -0,0 +1,15 @@
+module LVMWrapper 
+  class PhysicalVolume 
+    def initialize(args)
+        @attributes = args
+        
+        # so many attributes.. we let the caller define them :)
+        meta = class << self; self; end
+        args.each_key do |name|
+          meta.send(:define_method, name) { @attributes[name] }
+        end
+    end
+
+    # helper methods
+  end # class
+end # module

data/lib/lvm/pvmanager.rb

@@ -0,0 +1,22 @@
+require 'lvm/pv'
+require 'lvm/pvs'
+require 'lvm/pvseg'
+
+module LVMWrapper
+  class PhysicalVolumeManager
+      
+    def initialize(lvm)
+      @lvm = lvm
+    end
+
+    def create(args)
+    end
+
+    def list 
+      data = @lvm.cmd(PVS.command)
+      PVS.parse(data)
+    end
+    alias pvs list
+
+  end # class
+end # module

data/lib/lvm/pvs.rb

@@ -0,0 +1,109 @@
+module LVMWrapper 
+  class PVS
+    require 'yaml'
+
+    BASE_COMMAND = 'pvs --verbose --separator=, --noheadings --nosuffix --units=b --unbuffered --options %s' 
+    ATTRIBUTES = 'attrib/pvs.yaml'
+
+    EMPTY = '-'
+
+    # 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 self.command
+      opts = []
+      attributes = YAML.load_file(File.dirname(__FILE__) + '/' + ATTRIBUTES)
+      attributes.each do |a|
+        opts << a[:option]
+      end
+      
+      BASE_COMMAND % opts.join(",")
+    end
+
+    def self.parse_pv_attr(pv_attr)
+        ret = {}
+        # translate them into nice symbols and a couple booleans 
+        ret[:allocatable] = ALLOCATABLE[pv_attr[0].chr] ? true : false
+        ret[:exported] = EXPORTED[pv_attr[1].chr] ? true : false
+        ret
+    end
+
+    # Parses the output of self.command
+    def self.parse(output)
+      volumes = []
+      segs = []
+
+      # lvs columns will become lv attributes
+      attributes = YAML.load_file(File.dirname(__FILE__) + '/' + ATTRIBUTES)
+  
+      output.split("\n").each do |line|
+        line.strip!
+        # each line of output is comma separated values
+        values = line.split(",")
+        # empty values to nil
+        values.map! do |value|
+          if value.empty?
+            nil
+          else
+            value
+          end
+        end
+        
+        args = {}
+        # match up attribute => value
+        values.size.times do |i|
+          method = attributes[i][:method].to_sym
+          value  = values[i]
+          # use our hints first for type conversion
+          if attributes[i][:type_hint] == "Integer"
+            value = value.to_i
+          elsif attributes[i][:type_hint] == "Float"
+            value = value.to_f
+          end
+          args[method] = value
+        end
+
+        # pvs produces duplicate lines while elaborating on the segments being
+        # used, collect the segment data
+        segs << PhysicalVolumeSegment.new(:start => args[:pvseg_start], :size => args[:pvseg_size])
+        if args[:pvseg_start] == args[:pe_alloc_count]
+          args[:segments] = segs.dup
+          # already have em
+          args.delete(:pvseg_start)
+          args.delete(:pvseg_size)
+          segs.clear
+        else
+          next
+        end
+
+        # 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
+  
+      volumes
+    end # parse
+  
+  end # class
+end # module 

data/lib/lvm/pvseg.rb

@@ -0,0 +1,14 @@
+module LVMWrapper 
+  class PhysicalVolumeSegment
+    attr_reader :start, :size, :finish
+
+    def initialize(args)
+        @start = args[:start]
+        @size = args[:size]
+
+        @finish = @start + @size
+    end
+
+    # helper methods
+  end # class
+end # module

data/lib/lvm/vg.rb

@@ -0,0 +1,15 @@
+module LVMWrapper
+  class VolumeGroup
+    def initialize(args)
+        @attributes = args
+        
+        # so many attributes.. we let the caller define them :)
+        meta = class << self; self; end
+        args.each_key do |name|
+          meta.send(:define_method, name) { @attributes[name] }
+        end
+    end
+
+    # helper methods
+  end # class
+end # module

data/lib/lvm/vgmanager.rb

@@ -0,0 +1,68 @@
+require 'lvm/vg'
+require 'lvm/vgs'
+
+module LVMWrapper
+  class VolumeGroupManager
+      
+    def initialize(lvm)
+      @lvm = lvm
+    end
+
+    # vgcfgbackup     Backup volume group configuration(s)
+    # vgcfgrestore    Restore volume group configuration
+    # vgchange        Change volume group attributes
+    # vgck            Check the consistency of volume group(s)
+    # vgconvert       Change volume group metadata format
+    # vgcreate        Create a volume group
+    # vgdisplay       Display volume group information
+    # vgexport        Unregister volume group(s) from the system
+    # vgextend        Add physical volumes to a volume group
+    # vgimport        Register exported volume group with system
+    # vgmerge         Merge volume groups
+    # vgmknodes       Create the special files for volume group devices in /dev
+    # vgreduce        Remove physical volume(s) from a volume group
+    # vgremove        Remove volume group(s)
+    # vgrename        Rename a volume group
+    # vgs             Display information about volume groups
+    # vgscan          Search for all volume groups
+    # vgsplit         Move physical volumes into a new volume group
+
+    def create(args)
+    end
+
+    def change(args)
+      vgname = args[:vgname] || nil
+
+      raise ArgumentError if vgname.nil?
+
+      args.delete(:vgname)
+
+      @lvm.cmd("vgchange #{args_to_long_opts(args)} #{vgname}")
+    end
+
+    # ruby hash of key values to long options
+    def args_to_long_opts(args)
+      opts = [] 
+      args.each do |key,value|
+        opts << "--#{key.to_s} #{value}"
+      end
+      opts.join(" ")
+    end
+
+    def lookup(vgname)
+      raw_data = @lvm.cmd("#{VGS.command} #{vgname}")
+      VGS.parse(raw_data)[0]
+    end
+
+    def [](vgname)
+      lookup(vgname)
+    end
+
+    def list 
+      data = @lvm.cmd(VGS.command)
+      VGS.parse(data)
+    end
+    alias vgs list 
+
+  end # class
+end # module

data/lib/lvm/vgs.rb

@@ -0,0 +1,123 @@
+module LVMWrapper
+  class VGS
+    require 'yaml'
+
+    BASE_COMMAND = 'vgs --verbose --separator=, --noheadings --nosuffix --units=b --unbuffered --options %s' 
+    ATTRIBUTES = 'attrib/vgs.yaml'
+
+    EMPTY = '-'
+
+    # 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 self.command
+      opts = []
+      attributes = YAML.load_file(File.dirname(__FILE__) + '/' + ATTRIBUTES)
+      attributes.each do |a|
+        opts << a[:option]
+      end
+      
+      BASE_COMMAND % opts.join(",")
+    end
+
+    def self.parse_vg_attr(vg_attr)
+        ret = {}
+        # translate them into nice symbols and a couple booleans 
+        ret[:permissions] = PERMISSIONS[vg_attr[0].chr]
+        ret[:resizeable] = RESIZEABLE[vg_attr[1].chr] ? true : false
+        ret[:exported] = EXPORTED[vg_attr[2].chr] ? true : false
+        ret[:partial] = PARTIAL[vg_attr[3].chr] ? true : false
+        ret[:allocation_policy] = ALLOCATION_POLICY[vg_attr[4].chr]
+        ret[:clustered] = CLUSTERED[vg_attr[5].chr] ? true : false
+        ret
+    end
+
+    # Parses the output of self.command
+    def self.parse(output)
+      volumes = []
+
+      # lvs columns will become lv attributes
+      attributes = YAML.load_file(File.dirname(__FILE__) + '/' + ATTRIBUTES)
+  
+      output.split("\n").each do |line|
+        line.strip!
+        # each line of output is comma separated values
+        values = line.split(",")
+        # empty values to nil
+        values.map! do |value|
+          if value.empty?
+            nil
+          else
+            value
+          end
+        end
+        
+        args = {}
+        # match up attribute => value
+        values.size.times do |i|
+          method = attributes[i][:method].to_sym
+          value  = values[i]
+          # use our hints first for type conversion
+          if attributes[i][:type_hint] == "Integer"
+            value = value.to_i
+          elsif attributes[i][:type_hint] == "Float"
+            value = value.to_f
+          end
+          args[method] = value
+        end
+
+        # 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
+  
+      volumes
+    end # parse
+  
+  end # class
+end # module 

data/lib/lvm.rb

@@ -0,0 +1,39 @@
+require 'lvm/external'
+
+module LVMWrapper
+  VERSION = '0.0.1'
+  COMPAT_VERSION = '2.02.26-RHEL5'
+
+  class LVM
+    class LVM < Exception; end
+    
+    attr_accessor :command
+
+    DEFAULT_COMMAND = '/sbin/lvm'
+
+    def initialize(args = {})
+      @command = args[:command] || DEFAULT_COMMAND
+      @debug = args[:debug] || false
+    end
+
+    def raw(args) #:nodoc:
+      External.cmd(args)
+    end
+
+    def cmd(args)
+      to_exec = "#{@command} #{args}"
+      puts "Going to execute `#{to_exec}`" if @debug
+      raw(to_exec)
+    end
+
+    class<<self
+      def raw(args)
+        new(args).raw(args)
+      end
+      def cmd(args)
+        new(args).raw(args)
+      end
+    end # self
+
+  end # class
+end # module