linux_admin 0.1.2 → 0.1.3

data/lib/linux_admin/common.rb

@@ -1,16 +1,7 @@
 require 'shellwords'
 
 class LinuxAdmin
-  class CommandError < RuntimeError; end
-
   module Common
-    def write(file, content)
-      raise ArgumentError, "file and content can not be empty" if file.blank? || content.blank?
-      File.open(file, "w") do |f|
-        f.write(content)
-      end
-    end
-
     def cmd(cmd)
       Distro.local.class::COMMANDS[cmd]
     end
@@ -19,7 +10,9 @@ class LinuxAdmin
       params = options[:params] || options[:parameters]
 
       begin
-        out = launch(build_cmd(cmd, params))
+        launch_params = {}
+        launch_params[:chdir] = options[:chdir] if options[:chdir]
+        out = launch(build_cmd(cmd, params), launch_params)
 
         if options[:return_output] && exitstatus == 0
           out
@@ -67,9 +60,9 @@ class LinuxAdmin
     # http://stackoverflow.com/questions/13829830/ruby-process-spawn-stdout-pipe-buffer-size-limit/13846146#13846146
     THREAD_SYNC_KEY = "LinuxAdmin-exitstatus"
 
-    def launch(cmd)
+    def launch(cmd, spawn_options = {})
       pipe_r, pipe_w = IO.pipe
-      pid = Kernel.spawn(cmd, :err => [:child, :out], :out => pipe_w)
+      pid = Kernel.spawn(cmd, {:err => [:child, :out], :out => pipe_w}.merge(spawn_options))
       wait_for_process(pid, pipe_w)
       wait_for_output(pipe_r)
     end

data/lib/linux_admin/disk.rb

@@ -19,33 +19,72 @@ class LinuxAdmin
       @path = args[:path]
     end
 
+    def size
+      @size ||= begin
+        size = nil
+        out = run(cmd(:fdisk),
+                  :return_output => true,
+                  :params => {"-l" => nil})
+        out.each_line { |l|
+          if l =~ /Disk #{path}: ([0-9\.]*) ([KMG])B.*/
+            size = case $2
+                   when 'K' then
+                     $1.to_f.kilobytes
+                   when 'M' then
+                     $1.to_f.megabytes
+                   when 'G' then
+                     $1.to_f.gigabytes
+                   end
+            break
+          end
+        }
+        size
+      end
+    end
+
     def partitions
       @partitions ||= begin
         partitions = []
 
         # requires sudo
         out = run(cmd(:parted),
+                  :return_exitstatus => true,
                   :return_output => true,
                   :params => { nil => [@path, 'print'] })
 
+        return [] if out.kind_of?(Fixnum)
+
         out.each_line do |l|
           if l =~ /^ [0-9].*/
             p = l.split
-            id,size,fs_type = p[0], p[3], p[5]
-            if size =~ /([0-9\.]*)([KMG])B/
-              size = case $2
-                     when 'K' then
-                       $1.to_f.kilobytes
-                     when 'M' then
-                       $1.to_f.megabytes
-                     when 'G' then
-                       $1.to_f.gigabytes
-                     end
+            args = {:disk => self}
+            fields = [:id, :start_sector, :end_sector,
+                      :size, :partition_type, :fs_type]
+
+            fields.each_index do |i|
+              val = p[i]
+              case fields[i]
+              when :start_sector, :end_sector, :size
+                if val =~ /([0-9\.]*)([KMG])B/
+                  val = case $2
+                        when 'K' then
+                          $1.to_f.kilobytes
+                        when 'M' then
+                          $1.to_f.megabytes
+                        when 'G' then
+                          $1.to_f.gigabytes
+                        end
+                end
+
+              when :id
+                val = val.to_i
+
+              end
+
+              args[fields[i]] = val
             end
-            partitions << Partition.new(:disk => self,
-                                        :id => id.to_i,
-                                        :size => size,
-                                        :fs_type => fs_type)
+            partitions << Partition.new(args)
+
           end
         end
 
@@ -53,8 +92,35 @@ class LinuxAdmin
       end
     end
 
-    def create_partition
-      # TODO
+    def create_partition(partition_type, size)
+      id, start =
+        partitions.empty? ? [1, 0] :
+          [(partitions.last.id + 1),
+            partitions.last.end_sector]
+
+      run(cmd(:parted),
+          :params => { nil => [path, 'mkpart', partition_type,
+                               start, start + size]})
+
+      partition = Partition.new(:disk           => self,
+                                :id             => id,
+                                :start_sector   => start,
+                                :end_sector     => start+size,
+                                :size           => size,
+                                :partition_type => partition_type)
+      partitions << partition
+      partition
+    end
+
+    def clear!
+      @partitions = []
+
+      # clear partition table
+      run(cmd(:dd),
+          :params => { 'if=' => '/dev/zero', 'of=' => @path,
+                       'bs=' => 512, 'count=' => 1})
+
+      self
     end
   end
 end

data/lib/linux_admin/distro.rb

@@ -17,7 +17,7 @@ class LinuxAdmin
           issue = File.read('/etc/issue')
           if issue.include?('ubuntu')
             return Distros.ubuntu
-          elsif ['Fedora', 'red hat', 'centos'].any? { |d| issue.include?(d) }
+          elsif ['Fedora', 'red hat', 'Red Hat', 'centos'].any? { |d| issue.include?(d) }
             return Distros.redhat
           end
 
@@ -58,12 +58,23 @@ class LinuxAdmin
     end
 
     class RedHat < Distro
-      COMMANDS = {:service   => '/usr/sbin/service',
-                  :systemctl => '/usr/bin/systemctl',
-                  :parted    => '/usr/sbin/parted',
-                  :mount     => '/usr/bin/mount',
-                  :umount    => '/usr/bin/umount',
-                  :shutdown  => '/usr/sbin/shutdown'}
+      COMMANDS = {:service   => '/sbin/service',
+                  :systemctl => '/bin/systemctl',
+                  :parted    => '/sbin/parted',
+                  :mount     => '/bin/mount',
+                  :umount    => '/bin/umount',
+                  :shutdown  => '/sbin/shutdown',
+                  :mke2fs    => '/sbin/mke2fs',
+                  :fdisk     => '/sbin/fdisk',
+                  :dd        => '/bin/dd',
+                  :vgdisplay => '/sbin/vgdisplay',
+                  :pvdisplay => '/sbin/pvdisplay',
+                  :lvdisplay => '/sbin/lvdisplay',
+                  :lvextend  => '/sbin/lvextend',
+                  :vgextend  => '/sbin/vgextend',
+                  :lvcreate  => '/sbin/lvcreate',
+                  :pvcreate  => '/sbin/pvcreate',
+                  :vgcreate  => '/sbin/vgcreate'}
 
       def initialize
         @id = :redhat

data/lib/linux_admin/exceptions.rb

@@ -0,0 +1 @@
+  class CommandError < RuntimeError; end

data/lib/linux_admin/fstab.rb

@@ -24,6 +24,15 @@ class LinuxAdmin
       refresh
     end
 
+    def write!
+      content = ''
+      @entries.each do |entry|
+        content += "#{entry.device} #{entry.mount_point} #{entry.fs_type} #{entry.mount_options} #{entry.dumpable} #{entry.fsck_order}\n"
+      end
+      File.write('/etc/fstab', content)
+      self
+    end
+
     private
 
     def refresh

data/lib/linux_admin/logical_volume.rb

@@ -5,7 +5,71 @@
 
 class LinuxAdmin
   class LogicalVolume < LinuxAdmin
-    def initialize
+    # logical volume name
+    attr_accessor :name
+
+    # volume group name
+    attr_accessor :volume_group
+
+    # logical volume size in sectors
+    attr_accessor :sectors
+
+    # other fields available:
+    # logical volume access
+    # logical volume status
+    # internal logical volume number
+    # open count of logical volume
+    # current logical extents associated to logical volume
+    # allocated logical extents of logical volume
+    # allocation policy of logical volume
+    # read ahead sectors of logical volume
+    # major device number of logical volume
+    # minor device number of logical volume
+
+    def initialize(args = {})
+      @name         = args[:name]
+      @volume_group = args[:volume_group]
+      @sectors      = args[:sectors]
+    end
+
+    def extend_with(vg)
+      run(cmd(:lvextend),
+          :params => [self.name, vg.name])
+      self
+    end
+
+    def self.create(name, vg, size)
+      self.scan # initialize local logical volumes
+      run(cmd(:lvcreate),
+          :params => { '-n' => name, nil => vg.name, '-L' => size})
+      lv = LogicalVolume.new :name => name,
+                             :volume_group => vg,
+                             :sectors => size
+      @lvs << lv
+      lv
+    end
+
+    def self.scan
+      @lvs ||= begin
+        vgs = VolumeGroup.scan
+        lvs = []
+
+        out = run(cmd(:lvdisplay),
+                  :return_output => true,
+                  :params => { '-c' => nil})
+
+        out.each_line do |line|
+          fields = line.split(':')
+          vgname = fields[1] 
+          vg = vgs.find { |vg| vg.name == vgname }
+
+          lvs << LogicalVolume.new(:name         => fields[0],
+                                   :volume_group => vg,
+                                   :sectors      => fields[6].to_i)
+        end
+
+        lvs
+      end
     end
   end
 end

data/lib/linux_admin/partition.rb

@@ -8,7 +8,10 @@ require 'fileutils'
 class LinuxAdmin
   class Partition < LinuxAdmin
     attr_accessor :id
+    attr_accessor :partition_type
     attr_accessor :fs_type
+    attr_accessor :start_sector
+    attr_accessor :end_sector
     attr_accessor :size
     attr_accessor :disk
     attr_accessor :mount_point
@@ -18,12 +21,21 @@ class LinuxAdmin
       @size    = args[:size]
       @disk    = args[:disk]
       @fs_type = args[:fs_type]
+      @start_sector   = args[:start_sector]
+      @end_sector     = args[:end_sector]
+      @partition_type = args[:partition_type]
     end
 
     def path
       "#{disk.path}#{id}"
     end
 
+    def format_to(filesystem)
+      run(cmd(:mke2fs),
+          :params => { '-t' => filesystem, nil => self.path})
+      @fs_type = filesystem
+    end
+
     def mount(mount_point=nil)
       @mount_point = mount_point
       @mount_point  =
@@ -38,9 +50,5 @@ class LinuxAdmin
       run(cmd(:umount),
           :params => { nil => [@mount_point] })
     end
-
-    def format_to(fs_type)
-      #TODO
-    end
   end
 end

data/lib/linux_admin/physical_volume.rb

@@ -0,0 +1,75 @@
+# LinuxAdmin Physical Volume Representation
+#
+# Copyright (C) 2013 Red Hat Inc.
+# Licensed under the MIT License
+
+class LinuxAdmin
+  class PhysicalVolume < LinuxAdmin
+    # physical volume device name
+    attr_accessor :device_name
+
+    # volume group name
+    attr_accessor :volume_group
+
+    # physical volume size in kilobytes
+    attr_accessor :size
+
+    # other fields available
+    # internal physical volume number (obsolete)
+    # physical volume status
+    # physical volume (not) allocatable
+    # current number of logical volumes on this physical volume
+    # physical extent size in kilobytes
+    # total number of physical extents
+    # free number of physical extents
+    # allocated number of physical extents
+
+    def initialize(args = {})
+      @device_name  = args[:device_name]
+      @volume_group = args[:volume_group]
+      @size         = args[:size]
+    end
+
+    def attach_to(vg)
+      run(cmd(:vgextend),
+          :params => [vg.name, @device_name])
+      self.volume_group = vg
+      self
+    end
+
+    # specify disk or partition instance to create physical volume on
+    def self.create(device)
+      self.scan # initialize local physical volumes
+      run(cmd(:pvcreate),
+          :params => { nil => device.path})
+      pv  = PhysicalVolume.new(:device_name  => device.path,
+                               :volume_group => nil,
+                               :size => device.size)
+      @pvs << pv
+      pv
+    end
+
+    def self.scan
+      @pvs ||= begin
+        vgs = VolumeGroup.scan
+        pvs = []
+
+        out = run(cmd(:pvdisplay),
+                  :return_output => true,
+                  :params => { '-c' => nil})
+
+        out.each_line do |line|
+          fields = line.split(':')
+          vgname = fields[1]
+          vg = vgs.find { |vg| vg.name == vgname}
+
+          pvs << PhysicalVolume.new(:device_name  => fields[0],
+                                    :volume_group => vg,
+                                    :size         => fields[2].to_i)
+        end
+
+        pvs
+      end
+    end
+  end
+end

data/lib/linux_admin/{rhn.rb → registration_system/rhn.rb}

@@ -1,12 +1,8 @@
 require 'nokogiri'
 
 class LinuxAdmin
-  class Rhn < LinuxAdmin
-    def self.systemid_file
-      "/etc/sysconfig/rhn/systemid"
-    end
-
-    def self.registered?
+  class Rhn < RegistrationSystem
+    def registered?
       id = ""
       if File.exists?(systemid_file)
         xml = Nokogiri.XML(File.read(systemid_file))
@@ -15,7 +11,7 @@ class LinuxAdmin
       id.length > 0
     end
 
-    def self.register(options)
+    def register(options)
       cmd    = "rhnreg_ks"
       params = {}
 
@@ -36,7 +32,7 @@ class LinuxAdmin
       run(cmd, :params => params)
     end
 
-    def self.subscribe(options)
+    def subscribe(options)
       raise ArgumentError, "pools, username and password are required" if options[:pools].blank? || options[:username].blank? || options[:password].blank?
       cmd = "rhn-channel -a"
 
@@ -49,5 +45,11 @@ class LinuxAdmin
 
       run(cmd, :params => params)
     end
+
+    private
+
+    def systemid_file
+      "/etc/sysconfig/rhn/systemid"
+    end
   end
 end

data/lib/linux_admin/registration_system/subscription_manager.rb

@@ -0,0 +1,89 @@
+require 'date'
+
+class LinuxAdmin
+  class SubscriptionManager < RegistrationSystem
+
+    def validate_credentials(options)
+      !!organizations(options)
+    end
+
+    def registered?
+      run("subscription-manager identity", :return_exitstatus => true) == 0
+    end
+
+    def refresh
+      run("subscription-manager refresh")
+    end
+
+    def organizations(options)
+      raise ArgumentError, "username and password are required" unless options[:username] && options[:password]
+      cmd = "subscription-manager orgs"
+
+      params = {"--username=" => options[:username], "--password=" => options[:password]}
+      params.merge!(proxy_params(options))
+      params["--serverurl="]  = options[:server_url]  if options[:server_url]
+
+      output = run(cmd, :params => params, :return_output => true)
+      parse_output(output).index_by {|i| i[:name]}
+    end
+
+    def register(options)
+      raise ArgumentError, "username and password are required" unless options[:username] && options[:password]
+      cmd = "subscription-manager register"
+
+      params = {"--username=" => options[:username], "--password=" => options[:password]}
+      params.merge!(proxy_params(options))
+      params["--org="]        = options[:org]         if options[:server_url] && options[:org]
+      params["--serverurl="]  = options[:server_url]  if options[:server_url]
+
+      run(cmd, :params => params)
+    end
+
+    def subscribe(options)
+      cmd    = "subscription-manager attach"
+      pools  = options[:pools].collect {|pool| ["--pool", pool]}
+      params = proxy_params(options).to_a + pools
+
+      run(cmd, :params => params)
+    end
+
+    def available_subscriptions
+      cmd     = "subscription-manager list --all --available"
+      output  = run(cmd, :return_output => true)
+      parse_output(output).index_by {|i| i[:pool_id]}
+    end
+
+    private
+
+    def parse_output(output)
+      # Strip the 3 line header off the top
+      content = output.split("\n")[3..-1].join("\n")
+      parse_content(content)
+    end
+
+    def parse_content(content)
+      # Break into content groupings by "\n\n" then process each grouping
+      content.split("\n\n").each_with_object([]) do |group, group_array|
+        group = group.split("\n").each_with_object({}) do |line, hash|
+          next if line.blank?
+          key, value = line.split(":", 2)
+          hash[key.strip.downcase.tr(" -", "_").to_sym] = value.strip
+        end
+        group_array.push(format_values(group))
+      end
+    end
+
+    def format_values(content_group)
+      content_group[:ends] = Date.strptime(content_group[:ends], "%m/%d/%Y") if content_group[:ends]
+      content_group
+    end
+
+    def proxy_params(options)
+      config = {}
+      config["--proxy="]          = options[:proxy_address]   if options[:proxy_address]
+      config["--proxyuser="]      = options[:proxy_username]  if options[:proxy_username]
+      config["--proxypassword="]  = options[:proxy_password]  if options[:proxy_password]
+      config
+    end
+  end
+end

data/lib/linux_admin/registration_system.rb

@@ -0,0 +1,45 @@
+class LinuxAdmin
+  class RegistrationSystem < LinuxAdmin
+    def self.registration_type(reload = false)
+      return @registration_type if @registration_type && !reload
+      @registration_type = registration_type_uncached
+    end
+
+    def self.method_missing(meth, *args, &block)
+      if white_list_methods.include?(meth)
+        r = self.registration_type.new
+        raise NotImplementedError, "#{meth} not implemented for #{self.name}" unless r.respond_to?(meth)
+        r.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+
+    def registered?
+      false
+    end
+
+    private
+
+    def self.registration_type_uncached
+      if SubscriptionManager.new.registered?
+        SubscriptionManager
+      elsif Rhn.new.registered?
+        Rhn
+      else
+        self
+      end
+    end
+    private_class_method :registration_type_uncached
+
+    def self.white_list_methods
+      @white_list_methods ||= begin
+        all_methods = RegistrationSystem.instance_methods(false) + Rhn.instance_methods(false) + SubscriptionManager.instance_methods(false)
+        all_methods.uniq
+      end
+    end
+    private_class_method :white_list_methods
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), "registration_system", "*.rb")).each { |f| require f }

data/lib/linux_admin/version.rb

@@ -1,3 +1,3 @@
 class LinuxAdmin
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/linux_admin/volume_group.rb

@@ -0,0 +1,73 @@
+# LinuxAdmin Volume Group Representation
+#
+# Copyright (C) 2013 Red Hat Inc.
+# Licensed under the MIT License
+
+class LinuxAdmin
+  class VolumeGroup < LinuxAdmin
+    # volume group name
+    attr_accessor :name
+
+    # other fields available
+    # volume group access
+    # volume group status
+    # internal volume group number
+    # maximum number of logical volumes
+    # current number of logical volumes
+    # open count of all logical volumes in this volume group
+    # maximum logical volume size
+    # maximum number of physical volumes
+    # current number of physical volumes
+    # actual number of physical volumes
+    # size of volume group in kilobytes
+    # physical extent size
+    # total number of physical extents for this volume group
+    # allocated number of physical extents for this volume group
+    # free number of physical extents for this volume group
+    # uuid of volume group
+
+    def initialize(args = {})
+      @name   = args[:name]
+    end
+
+    def attach_to(lv)
+      run(cmd(:lvextend),
+          :params => [lv.name, self.name])
+      self
+    end
+
+    def extend_with(pv)
+      run(cmd(:vgextend),
+          :params => [@name, pv.device_name])
+      pv.volume_group = self
+      self
+    end
+
+    def self.create(name, pv)
+      self.scan # initialize local volume groups
+      run(cmd(:vgcreate),
+          :params => [name, pv.device_name])
+      vg = VolumeGroup.new :name => name
+      pv.volume_group = vg
+      @vgs << vg
+      vg
+    end
+
+    def self.scan
+      @vgs ||= begin
+        vgs = []
+
+        out = run(cmd(:vgdisplay),
+                  :return_output => true,
+                  :params => { '-c' => nil})
+
+        out.each_line do |line|
+          fields = line.split(':')
+          vgs << VolumeGroup.new(:name   => fields[0])
+        end
+
+        vgs
+      end
+    end
+  end
+end

data/lib/linux_admin/yum.rb

@@ -59,7 +59,7 @@ class LinuxAdmin
     end
 
     def self.version_available(*packages)
-      raise ArgumentError, "packages requires at least one package name" unless packages
+      raise ArgumentError, "packages requires at least one package name" if packages.blank?
 
       cmd    = "repoquery --qf=\"%{name} %{version}\""
       params = {nil => packages}