linux_admin 0.14.0 → 0.15.0

data/lib/linux_admin/service/sys_v_init_service.rb

@@ -1,38 +1,38 @@
 module LinuxAdmin
   class SysVInitService < Service
     def running?
-      run(cmd(:service),
-          :params => { nil => [name, "status"] }).exit_status == 0
+      Common.run(Common.cmd(:service),
+                 :params => {nil => [name, "status"]}).exit_status == 0
     end
 
     def enable
-      run!(cmd(:chkconfig),
-          :params => { nil => [name, "on"] })
+      Common.run!(Common.cmd(:chkconfig),
+                  :params => {nil => [name, "on"]})
       self
     end
 
     def disable
-      run!(cmd(:chkconfig),
-          :params => { nil => [name, "off"] })
+      Common.run!(Common.cmd(:chkconfig),
+                  :params => {nil => [name, "off"]})
       self
     end
 
     def start
-      run!(cmd(:service),
-          :params => { nil => [name, "start"] })
+      Common.run!(Common.cmd(:service),
+                  :params => {nil => [name, "start"]})
       self
     end
 
     def stop
-      run!(cmd(:service),
-          :params => { nil => [name, "stop"] })
+      Common.run!(Common.cmd(:service),
+                  :params => {nil => [name, "stop"]})
       self
     end
 
     def restart
       status =
-        run(cmd(:service),
-          :params => { nil => [name, "restart"] }).exit_status
+        Common.run(Common.cmd(:service),
+                   :params => {nil => [name, "restart"]}).exit_status
 
       # attempt to manually stop/start if restart fails
       if status != 0

data/lib/linux_admin/service/systemd_service.rb

@@ -1,38 +1,38 @@
 module LinuxAdmin
   class SystemdService < Service
     def running?
-      run(cmd(:systemctl),
-          :params => {nil => ["status", name]}).exit_status == 0
+      Common.run(Common.cmd(:systemctl),
+                 :params => {nil => ["status", name]}).exit_status == 0
     end
 
     def enable
-      run!(cmd(:systemctl),
-           :params => {nil => ["enable", name]})
+      Common.run!(Common.cmd(:systemctl),
+                  :params => {nil => ["enable", name]})
       self
     end
 
     def disable
-      run!(cmd(:systemctl),
-           :params => {nil => ["disable", name]})
+      Common.run!(Common.cmd(:systemctl),
+                  :params => {nil => ["disable", name]})
       self
     end
 
     def start
-      run!(cmd(:systemctl),
-           :params => {nil => ["start", name]})
+      Common.run!(Common.cmd(:systemctl),
+                  :params => {nil => ["start", name]})
       self
     end
 
     def stop
-      run!(cmd(:systemctl),
-           :params => {nil => ["stop", name]})
+      Common.run!(Common.cmd(:systemctl),
+                  :params => {nil => ["stop", name]})
       self
     end
 
     def restart
       status =
-        run(cmd(:systemctl),
-            :params => {nil => ["restart", name]}).exit_status
+        Common.run(Common.cmd(:systemctl),
+                   :params => {nil => ["restart", name]}).exit_status
 
       # attempt to manually stop/start if restart fails
       if status != 0

data/lib/linux_admin/service.rb

@@ -1,7 +1,5 @@
 module LinuxAdmin
   class Service
-    extend Common
-    include Common
     include Logging
 
     def self.service_type(reload = false)
@@ -34,7 +32,7 @@ module LinuxAdmin
     private
 
     def self.service_type_uncached
-      cmd?(:systemctl) ? SystemdService : SysVInitService
+      Common.cmd?(:systemctl) ? SystemdService : SysVInitService
     end
     private_class_method :service_type_uncached
   end

data/lib/linux_admin/system.rb

@@ -1,14 +1,12 @@
 module LinuxAdmin
   class System
-    extend Common
-
     def self.reboot!
-      run!(cmd(:shutdown),
+      Common.run!(Common.cmd(:shutdown),
           :params => { "-r" => "now" })
     end
 
     def self.shutdown!
-      run!(cmd(:shutdown),
+      Common.run!(Common.cmd(:shutdown),
           :params => { "-h" => "0" })
     end
   end

data/lib/linux_admin/time_date.rb

@@ -1,12 +1,11 @@
 module LinuxAdmin
   class TimeDate
-    extend Common
     COMMAND = 'timedatectl'
 
     TimeCommandError = Class.new(StandardError)
 
     def self.system_timezone_detailed
-      result = run(cmd(COMMAND), :params => ["status"])
+      result = Common.run(Common.cmd(COMMAND), :params => ["status"])
       result.output.split("\n").each do |l|
         return l.split(':')[1].strip if l =~ /Time.*zone/
       end
@@ -17,13 +16,13 @@ module LinuxAdmin
     end
 
     def self.system_time=(time)
-      run!(cmd(COMMAND), :params => ["set-time", "#{time.strftime("%F %T")}", :adjust_system_clock])
+      Common.run!(Common.cmd(COMMAND), :params => ["set-time", "#{time.strftime("%F %T")}", :adjust_system_clock])
     rescue AwesomeSpawn::CommandResultError => e
       raise TimeCommandError, e.message
     end
 
     def self.system_timezone=(zone)
-      run!(cmd(COMMAND), :params => ["set-timezone", zone])
+      Common.run!(Common.cmd(COMMAND), :params => ["set-timezone", zone])
     rescue AwesomeSpawn::CommandResultError => e
       raise TimeCommandError, e.message
     end

data/lib/linux_admin/version.rb

@@ -1,3 +1,3 @@
 module LinuxAdmin
-  VERSION = "0.14.0"
+  VERSION = "0.15.0"
 end

data/lib/linux_admin/volume.rb

@@ -15,7 +15,7 @@ module LinuxAdmin
     def self.scan_volumes(cmd)
       volumes = []
 
-      out = run!(cmd, :params => { '-c' => nil}).output
+      out = Common.run!(cmd, :params => {'-c' => nil}).output
 
       out.each_line do |line|
         fields, vg = process_volume_display_line(line.lstrip)

data/lib/linux_admin/volume_group.rb

@@ -1,8 +1,5 @@
 module LinuxAdmin
   class VolumeGroup
-    include Common
-    extend Common
-
     # volume group name
     attr_accessor :name
 
@@ -29,22 +26,22 @@ module LinuxAdmin
     end
 
     def attach_to(lv)
-      run!(cmd(:lvextend),
-          :params => [lv.name, self.name])
+      Common.run!(Common.cmd(:lvextend),
+                  :params => [lv.name, name])
       self
     end
 
     def extend_with(pv)
-      run!(cmd(:vgextend),
-          :params => [@name, pv.device_name])
+      Common.run!(Common.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])
+      Common.run!(Common.cmd(:vgcreate),
+                  :params => [name, pv.device_name])
       vg = VolumeGroup.new :name => name
       pv.volume_group = vg
       @vgs << vg
@@ -55,7 +52,7 @@ module LinuxAdmin
       @vgs ||= begin
         vgs = []
 
-        out = run!(cmd(:vgdisplay), :params => { '-c' => nil}).output
+        out = Common.run!(Common.cmd(:vgdisplay), :params => {'-c' => nil}).output
 
         out.each_line do |line|
           fields = line.lstrip.split(':')

data/lib/linux_admin/yum.rb

@@ -3,8 +3,6 @@ require 'inifile'
 
 module LinuxAdmin
   class Yum
-    extend Common
-
     def self.create_repo(path, options = {})
       raise ArgumentError, "path is required" unless path
       options = options.reverse_merge(:database => true, :unique_file_names => true)
@@ -16,7 +14,7 @@ module LinuxAdmin
       params["--database"]            = nil  if options[:database]
       params["--unique-md-filenames"] = nil  if options[:unique_file_names]
 
-      run!(cmd, :params => params)
+      Common.run!(cmd, :params => params)
     end
 
     def self.download_packages(path, packages, options = {})
@@ -34,7 +32,7 @@ module LinuxAdmin
       params["-a"]  = options[:arch] if options[:arch]
       params[nil]   = packages
 
-      run!(cmd, :params => params)
+      Common.run!(cmd, :params => params)
     end
 
     def self.repo_settings
@@ -45,7 +43,7 @@ module LinuxAdmin
       cmd    = "yum check-update"
       params = {nil => packages} unless packages.blank?
 
-      exitstatus = run(cmd, :params => params).exit_status
+      exitstatus = Common.run(cmd, :params => params).exit_status
       case exitstatus
       when 0;   false
       when 100; true
@@ -57,7 +55,7 @@ module LinuxAdmin
       cmd    = "yum -y update"
       params = {nil => packages} unless packages.blank?
 
-      out = run!(cmd, :params => params)
+      out = Common.run!(cmd, :params => params)
 
       # Handle errors that exit 0  https://bugzilla.redhat.com/show_bug.cgi?id=1141318
       raise AwesomeSpawn::CommandResultError.new(out.error, out) if out.error.include?("No Match for argument")
@@ -71,7 +69,7 @@ module LinuxAdmin
       cmd    = "repoquery --qf=\"%{name} %{version}\""
       params = {nil => packages}
 
-      out = run!(cmd, :params => params).output
+      out = Common.run!(cmd, :params => params).output
 
       out.split("\n").each_with_object({}) do |i, versions|
         name, version         = i.split(" ", 2)
@@ -84,7 +82,7 @@ module LinuxAdmin
 
       cmd     = "yum repolist"
       params  = {nil => scope}
-      output  = run!(cmd, :params => params).output
+      output  = Common.run!(cmd, :params => params).output
 
       parse_repo_list_output(output)
     end

data/lib/linux_admin.rb

@@ -36,8 +36,6 @@ require 'linux_admin/network_interface'
 require 'linux_admin/chrony'
 
 module LinuxAdmin
-  extend Common
-
   class << self
     attr_writer :logger
   end

data/spec/common_spec.rb

@@ -1,37 +1,35 @@
 describe LinuxAdmin::Common do
-  subject { Class.new { include LinuxAdmin::Common }.new }
-
   describe "#cmd" do
     it "looks up local command from id" do
-      expect(subject.cmd(:dd)).to match(/bin\/dd/)
+      expect(described_class.cmd(:dd)).to match(%r{bin/dd})
     end
 
     it "returns nil when it can't find the command" do
-      expect(subject.cmd(:kasgbdlcvjhals)).to be_nil
+      expect(described_class.cmd(:kasgbdlcvjhals)).to be_nil
     end
   end
 
   describe "#cmd?" do
     it "returns true when the command exists" do
-      expect(subject.cmd?(:dd)).to be true
+      expect(described_class.cmd?(:dd)).to be true
     end
 
     it "returns false when the command doesn't exist" do
-      expect(subject.cmd?(:kasgbdlcvjhals)).to be false
+      expect(described_class.cmd?(:kasgbdlcvjhals)).to be false
     end
   end
 
   describe "#run" do
     it "runs a command with AwesomeSpawn.run" do
       expect(AwesomeSpawn).to receive(:run).with("echo", nil => "test")
-      subject.run("echo", nil => "test")
+      described_class.run("echo", nil => "test")
     end
   end
 
   describe "#run!" do
     it "runs a command with AwesomeSpawn.run!" do
       expect(AwesomeSpawn).to receive(:run!).with("echo", nil => "test")
-      subject.run!("echo", nil => "test")
+      described_class.run!("echo", nil => "test")
     end
   end
 end

data/spec/deb_spec.rb

@@ -37,9 +37,9 @@ Origin: Ubuntu
 Supported: 9m
 Task: kubuntu-desktop, kubuntu-full, kubuntu-active, kubuntu-active-desktop, kubuntu-active-full, kubuntu-active, edubuntu-desktop-gnome, ubuntustudio-font-meta
 EOS
-      expect(described_class).to receive(:run!).
-                      with(described_class::APT_CACHE_CMD, :params => ["show", "ruby"]).
-                      and_return(double(:output => data))
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(described_class::APT_CACHE_CMD, :params => %w(show ruby))
+        .and_return(double(:output => data))
       metadata = described_class.info("ruby")
       expect(metadata['package']).to eq('ruby')
       expect(metadata['priority']).to eq('optional')

data/spec/disk_spec.rb

@@ -13,10 +13,10 @@ describe LinuxAdmin::Disk do
   describe "#size" do
     it "uses fdisk" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      expect(disk).to receive(:run!).
-        with(disk.cmd(:fdisk),
-             :params => {"-l" => nil}).
-        and_return(double(:output => ""))
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:fdisk),
+              :params => {"-l" => nil})
+        .and_return(double(:output => ""))
       disk.size
     end
 
@@ -36,7 +36,7 @@ Disk identifier: 0x3ddb508b
 eos
 
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      allow(disk).to receive(:run!).and_return(double(:output => fdisk))
+      allow(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => fdisk))
       expect(disk.size).to eq(500_107_862_016)
     end
   end
@@ -44,15 +44,15 @@ eos
   describe "#partitions" do
     it "uses parted" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      expect(disk).to receive(:run).
-        with(disk.cmd(:parted),
-             :params => { nil => %w(--script /dev/hda print) }).and_return(double(:output => ""))
+      expect(LinuxAdmin::Common).to receive(:run)
+        .with(LinuxAdmin::Common.cmd(:parted),
+              :params => {nil => %w(--script /dev/hda print)}).and_return(double(:output => ""))
       disk.partitions
     end
 
     it "returns [] on non-zero parted rc" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      expect(disk).to receive(:run).and_return(double(:output => "", :exit_status => 1))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:output => "", :exit_status => 1))
       expect(disk.partitions).to eq([])
     end
 
@@ -70,7 +70,7 @@ Number  Start   End     Size    Type      File system     Flags
  3      162GB   163GB   1074MB  logical   linux-swap(v1)
 eos
       disk = LinuxAdmin::Disk.new
-      expect(disk).to receive(:run).and_return(double(:output => partitions))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:output => partitions))
 
       expect(disk.partitions[0].id).to eq(1)
       expect(disk.partitions[0].disk).to eq(disk)
@@ -137,13 +137,13 @@ eos
 
     it "uses parted" do
       params = ['--script', '/dev/hda', 'mkpart', '-a', 'opt', 'primary', 1024, 2048]
-      expect(@disk).to receive(:run!).with(@disk.cmd(:parted), :params => { nil => params })
+      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:parted), :params => {nil => params})
       @disk.create_partition 'primary', 1024
     end
 
     it "accepts start/end params" do
       params = ['--script', '/dev/hda', 'mkpart', '-a', 'opt', 'primary', "0%", "50%"]
-      expect(@disk).to receive(:run!).with(@disk.cmd(:parted), :params => { nil => params })
+      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:parted), :params => {nil => params})
       @disk.create_partition 'primary', "0%", "50%"
     end
 
@@ -160,25 +160,25 @@ eos
     end
 
     it "returns partition" do
-      expect(@disk).to receive(:run!) # stub out call to parted
+      expect(LinuxAdmin::Common).to receive(:run!) # stub out call to parted
       partition = @disk.create_partition 'primary', 1024
       expect(partition).to be_an_instance_of(LinuxAdmin::Partition)
     end
 
     it "increments partition id" do
-      expect(@disk).to receive(:run!) # stub out call to parted
+      expect(LinuxAdmin::Common).to receive(:run!) # stub out call to parted
       partition = @disk.create_partition 'primary', 1024
       expect(partition.id).to eq(2)
     end
 
     it "sets partition start to first unused sector on disk" do
-      expect(@disk).to receive(:run!) # stub out call to parted
+      expect(LinuxAdmin::Common).to receive(:run!) # stub out call to parted
       partition = @disk.create_partition 'primary', 1024
       expect(partition.start_sector).to eq(1024)
     end
 
     it "stores new partition locally" do
-      expect(@disk).to receive(:run!) # stub out call to parted
+      expect(LinuxAdmin::Common).to receive(:run!) # stub out call to parted
       expect {
         @disk.create_partition 'primary', 1024
       }.to change{@disk.partitions.size}.by(1)
@@ -187,7 +187,7 @@ eos
     it "creates partition table if missing" do
       allow(@disk).to receive_messages(:has_partition_table? => false)
       expect(@disk).to receive(:create_partition_table)
-      expect(@disk).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       @disk.create_partition 'primary', 1024
     end
   end
@@ -195,14 +195,14 @@ eos
   describe "#has_partition_table?" do
     it "positive case" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      expect(disk).to receive(:run).and_return(double(:output => "", :exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:output => "", :exit_status => 0))
       expect(disk).to have_partition_table
     end
 
     it "negative case" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
       output = "\e[?1034h\r\rError: /dev/sdb: unrecognised disk label\n"
-      expect(disk).to receive(:run).and_return(double(:output => output, :exit_status => 1))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:output => output, :exit_status => 1))
       expect(disk).not_to have_partition_table
     end
   end
@@ -210,33 +210,33 @@ eos
   it "#create_partition_table" do
     disk = LinuxAdmin::Disk.new :path => '/dev/hda'
     options = {:params => {nil => %w(--script /dev/hda mklabel msdos)}}
-    expect(disk).to receive(:run!).with(disk.cmd(:parted), options)
+    expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:parted), options)
     disk.create_partition_table
   end
 
   describe "#clear!" do
     it "clears partitions" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      expect(disk).to receive(:run).and_return(double(:output => "")) # stub out call to cmds
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:output => "")) # stub out call to cmds
       disk.partitions << LinuxAdmin::Partition.new
 
-      expect(disk).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       disk.clear!
       expect(disk.partitions).to be_empty
     end
 
     it "uses dd to clear partition table" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      expect(disk).to receive(:run!).
-           with(disk.cmd(:dd),
-                :params => {'if=' => '/dev/zero', 'of=' => '/dev/hda',
-                            'bs=' => 512, 'count=' => 1})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:dd),
+              :params => {'if=' => '/dev/zero', 'of=' => '/dev/hda',
+                          'bs=' => 512, 'count=' => 1})
       disk.clear!
     end
 
     it "returns self" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      allow(disk).to receive(:run!) # stub out call to dd
+      allow(LinuxAdmin::Common).to receive(:run!) # stub out call to dd
       expect(disk.clear!).to eq(disk)
     end
   end