linux_admin 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0909517c6cc080f6c8a9a82a7b1119e3a8c50452
-  data.tar.gz: d2182ff8ce82b685d55e562968154010e486874c
+  metadata.gz: 45fe746b6f6401803b85ca5775c961a0fff87538
+  data.tar.gz: 748af8054c1540f1337541dbf02f9626a9d91ed8
 SHA512:
-  metadata.gz: 7ff4ffc9e1c2650ed0c127b1a2338e5476e7caa211198b471288b17f3874aa6a1b84cacbcafdc165eed7ad971e07ee5d4b53270d2bb593ccdfac378cdbbbd029
-  data.tar.gz: 9de9c8938028031bfe8f0793fe89f0e8e3dc6b329f4d6711842c43500ba41870f4bb5bf532e22206bd59f048a4879e92201c00c52ba5bc11f0c4e879fd3c49c3
+  metadata.gz: 8d31d976370bf3df926f66b0b075a2a3234b3f373faf4309eba1d1920163239e901297a9e846406e4c3e70429fcbb2c54feb01daef4cacc73e189468ad697ff0
+  data.tar.gz: e49ec88d3c04c0e2d56a75ec02d9814b9866e1c3144941160c390cd55182548959e3aaa8306ffbd07a6f51d1ed76a00ec5228ecce0dd052d265775e2989f4aef

data/lib/linux_admin/network_interface.rb

@@ -51,11 +51,10 @@ module LinuxAdmin
 
       @network_conf[:mac] = parse_ip_output(ip_output, %r{link/ether}, 1)
 
-      ip_route_res = Common.run!(Common.cmd("ip"), :params => ["route"])
-      @network_conf[:gateway] = parse_ip_output(ip_route_res.output, /^default/, 2) if ip_route_res.success?
+      [4, 6].each do |version|
+        @network_conf["gateway#{version}".to_sym] = parse_ip_output(ip_route(version), /^default/, 2)
+      end
       true
-    rescue AwesomeSpawn::CommandResultError => e
-      raise NetworkInterfaceError.new(e.message, e.result)
     end
 
     # Retrieve the IPv4 address assigned to the interface
@@ -91,7 +90,7 @@ module LinuxAdmin
     #
     # @return [String] IPv4 netmask
     def netmask
-      @network_conf[:mask]
+      @network_conf[:mask] ||= IPAddr.new('255.255.255.255').mask(prefix).to_s if prefix
     end
 
     # Retrieve the IPv6 sub-net mask assigned to the interface
@@ -99,10 +98,26 @@ module LinuxAdmin
     # @return [String] IPv6 netmask
     # @raise [ArgumentError] if the given scope is not `:global` or `:link`
     def netmask6(scope = :global)
-      if scope == :global
-        @network_conf[:mask6_global]
-      elsif scope == :link
-        @network_conf[:mask6_link]
+      if [:global, :link].include?(scope)
+        @network_conf["mask6_#{scope}".to_sym] ||= IPAddr.new('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff').mask(prefix6(scope)).to_s if prefix6(scope)
+      else
+        raise ArgumentError, "Unrecognized address scope #{scope}"
+      end
+    end
+
+    # Retrieve the IPv4 sub-net prefix length assigned to the interface
+    #
+    # @return [Numeric] IPv4 prefix length
+    def prefix
+      @network_conf[:prefix]
+    end
+
+    # Retrieve the IPv6 sub-net prefix length assigned to the interface
+    #
+    # @return [Numeric] IPv6 prefix length
+    def prefix6(scope = :global)
+      if [:global, :link].include?(scope)
+        @network_conf["prefix6_#{scope}".to_sym]
       else
         raise ArgumentError, "Unrecognized address scope #{scope}"
       end
@@ -112,7 +127,14 @@ module LinuxAdmin
     #
     # @return [String] IPv4 gateway address
     def gateway
-      @network_conf[:gateway]
+      @network_conf[:gateway4]
+    end
+
+    # Retrieve the IPv6 default gateway associated with the interface
+    #
+    # @return [String] IPv6 gateway address
+    def gateway6
+      @network_conf[:gateway6]
     end
 
     # Brings up the network interface
@@ -152,6 +174,17 @@ module LinuxAdmin
       raise NetworkInterfaceError.new(e.message, e.result)
     end
 
+    # Runs the command `ip -[4/6] route` and returns the output
+    #
+    # @param version [Fixnum] Version of IP protocol (4 or 6)
+    # @return [String] The command output
+    # @raise [NetworkInterfaceError] if the command fails
+    def ip_route(version)
+      Common.run!(Common.cmd("ip"), :params => ["-#{version}", 'route']).output
+    rescue AwesomeSpawn::CommandResultError => e
+      raise NetworkInterfaceError.new(e.message, e.result)
+    end
+
     # Parses the IPv4 information from the output of `ip addr show <device>`
     #
     # @param ip_output [String] The command output
@@ -159,8 +192,9 @@ module LinuxAdmin
       cidr_ip = parse_ip_output(ip_output, /inet /, 1)
       return unless cidr_ip
 
-      @network_conf[:address] = cidr_ip.split('/')[0]
-      @network_conf[:mask] = IPAddr.new('255.255.255.255').mask(cidr_ip.split('/')[1]).to_s
+      parts = cidr_ip.split('/')
+      @network_conf[:address] = parts[0]
+      @network_conf[:prefix] = parts[1].to_i
     end
 
     # Parses the IPv6 information from the output of `ip addr show <device>`
@@ -168,13 +202,12 @@ module LinuxAdmin
     # @param ip_output [String] The command output
     # @param scope     [Symbol] The IPv6 scope (either `:global` or `:local`)
     def parse_ip6(ip_output, scope)
-      mask_addr = IPAddr.new('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff')
       cidr_ip = parse_ip_output(ip_output, /inet6 .* scope #{scope}/, 1)
       return unless cidr_ip
 
       parts = cidr_ip.split('/')
       @network_conf["address6_#{scope}".to_sym] = parts[0]
-      @network_conf["mask6_#{scope}".to_sym] = mask_addr.mask(parts[1]).to_s
+      @network_conf["prefix6_#{scope}".to_sym] = parts[1].to_i
     end
   end
 end

data/lib/linux_admin/network_interface/network_interface_rh.rb

@@ -39,6 +39,18 @@ module LinuxAdmin
       @interface_config["IPADDR"]    = address
     end
 
+    # Set the IPv6 address for this interface
+    #
+    # @param address [String] IPv6 address including the prefix length (i.e. '::1/127')
+    # @raise ArgumentError if the address is not formatted properly
+    def address6=(address)
+      validate_ip(address)
+      @interface_config['BOOTPROTO'] = 'static'
+      @interface_config['IPV6INIT']  = 'yes'
+      @interface_config['DHCPV6C']   = 'no'
+      @interface_config['IPV6ADDR']  = address
+    end
+
     # Set the IPv4 gateway address for this interface
     #
     # @param address [String]
@@ -48,6 +60,15 @@ module LinuxAdmin
       @interface_config["GATEWAY"] = address
     end
 
+    # Set the IPv6 gateway address for this interface
+    #
+    # @param address [String] IPv6 address optionally including the prefix length
+    # @raise ArgumentError if the address is not formatted properly
+    def gateway6=(address)
+      validate_ip(address)
+      @interface_config['IPV6_DEFAULTGW'] = address
+    end
+
     # Set the IPv4 sub-net mask for this interface
     #
     # @param mask [String]
@@ -74,7 +95,7 @@ module LinuxAdmin
     end
 
     # Set up the interface to use DHCP
-    # Removes any previously set static networking information
+    # Removes any previously set static IPv4 networking information
     def enable_dhcp
       @interface_config["BOOTPROTO"] = "dhcp"
       @interface_config.delete("IPADDR")
@@ -86,6 +107,18 @@ module LinuxAdmin
       @interface_config.delete("DOMAIN")
     end
 
+    # Set up the interface to use DHCPv6
+    # Removes any previously set static IPv6 networking information
+    def enable_dhcp6
+      @interface_config['IPV6INIT'] = 'yes'
+      @interface_config['DHCPV6C'] = 'yes'
+      @interface_config.delete('IPV6ADDR')
+      @interface_config.delete('IPV6_DEFAULTGW')
+      @interface_config.delete("DNS1")
+      @interface_config.delete("DNS2")
+      @interface_config.delete("DOMAIN")
+    end
+
     # Applies the given static network configuration to the interface
     #
     # @param ip [String] IPv4 address
@@ -104,6 +137,23 @@ module LinuxAdmin
       save
     end
 
+    # Applies the given static IPv6 network configuration to the interface
+    #
+    # @param ip [String] IPv6 address
+    # @param prefix [Number] prefix length for IPv6 address
+    # @param gw [String] gateway address
+    # @param dns [Array<String>] list of dns servers
+    # @param search [Array<String>] list of search domains
+    # @return [Boolean] true on success, false otherwise
+    # @raise ArgumentError if an IP is not formatted properly or interface does not start
+    def apply_static6(ip, prefix, gw, dns, search = nil)
+      self.address6     = "#{ip}/#{prefix}"
+      self.gateway6     = gw
+      self.dns          = dns
+      self.search_order = search if search
+      save
+    end
+
     # Writes the contents of @interface_config to @interface_file as `key`=`value` pairs
     # and resets the interface
     #

data/lib/linux_admin/service/sys_v_init_service.rb

@@ -51,5 +51,9 @@ module LinuxAdmin
     def status
       Common.run(Common.cmd(:service), :params => [name, "status"]).output
     end
+
+    def show
+      raise NotImplementedError
+    end
   end
 end

data/lib/linux_admin/service/systemd_service.rb

@@ -1,38 +1,31 @@
 module LinuxAdmin
   class SystemdService < Service
     def running?
-      Common.run(Common.cmd(:systemctl),
-                 :params => {nil => ["status", name]}).exit_status == 0
+      Common.run(command_path, :params => ["status", name]).success?
     end
 
     def enable
-      Common.run!(Common.cmd(:systemctl),
-                  :params => {nil => ["enable", name]})
+      Common.run!(command_path, :params => ["enable", name])
       self
     end
 
     def disable
-      Common.run!(Common.cmd(:systemctl),
-                  :params => {nil => ["disable", name]})
+      Common.run!(command_path, :params => ["disable", name])
       self
     end
 
     def start
-      Common.run!(Common.cmd(:systemctl),
-                  :params => {nil => ["start", name]})
+      Common.run!(command_path, :params => ["start", name])
       self
     end
 
     def stop
-      Common.run!(Common.cmd(:systemctl),
-                  :params => {nil => ["stop", name]})
+      Common.run!(command_path, :params => ["stop", name])
       self
     end
 
     def restart
-      status =
-        Common.run(Common.cmd(:systemctl),
-                   :params => {nil => ["restart", name]}).exit_status
+      status = Common.run(command_path, :params => ["restart", name]).exit_status
 
       # attempt to manually stop/start if restart fails
       if status != 0
@@ -44,12 +37,43 @@ module LinuxAdmin
     end
 
     def reload
-      Common.run!(Common.cmd(:systemctl), :params => ["reload", name])
+      Common.run!(command_path, :params => ["reload", name])
       self
     end
 
     def status
-      Common.run(Common.cmd(:systemctl), :params => ["status", name]).output
+      Common.run(command_path, :params => ["status", name]).output
+    end
+
+    def show
+      output = Common.run!(command_path, :params => ["show", name]).output
+      output.split("\n").each_with_object({}) do |line, h|
+        k, v = line.split("=", 2)
+        h[k] = cast_show_value(k, v)
+      end
+    end
+
+    private
+
+    def command_path
+      Common.cmd(:systemctl)
+    end
+
+    def cast_show_value(key, value)
+      return value.to_i if value =~ /^\d+$/
+
+      case key
+      when /^.*Timestamp$/
+        Time.parse(value)
+      when /Exec(Start|Stop)/
+        parse_exec_value(value)
+      else
+        value
+      end
+    end
+
+    def parse_exec_value(value)
+      value[1..-2].strip.split(" ; ").map { |s| s.split("=", 2) }.to_h
     end
   end
 end

data/lib/linux_admin/version.rb

@@ -1,3 +1,3 @@
 module LinuxAdmin
-  VERSION = "0.19.0"
+  VERSION = "0.20.0".freeze
 end

data/spec/network_interface/network_interface_rh_spec.rb

@@ -40,14 +40,14 @@ EOF
   subject(:dhcp_interface) do
     allow(File).to receive(:exist?).and_return(true)
     stub_foreach_to_string(ifcfg_file_dhcp)
-    allow(AwesomeSpawn).to receive(:run!).twice.and_return(result("", 0))
+    allow(AwesomeSpawn).to receive(:run!).exactly(4).times.and_return(result("", 0))
     described_class.new(device_name)
   end
 
   subject(:static_interface) do
     allow(File).to receive(:exist?).and_return(true)
     stub_foreach_to_string(ifcfg_file_static)
-    allow(AwesomeSpawn).to receive(:run!).twice.and_return(result("", 0))
+    allow(AwesomeSpawn).to receive(:run!).exactly(4).times.and_return(result("", 0))
     described_class.new(device_name)
   end
 
@@ -100,6 +100,22 @@ EOF
     end
   end
 
+  describe '#address6=' do
+    it 'sets the ipv6 address' do
+      address = 'fe80::1/64'
+      dhcp_interface.address6 = address
+      conf = dhcp_interface.interface_config
+      expect(conf['IPV6ADDR']).to eq(address)
+      expect(conf['BOOTPROTO']).to eq('static')
+      expect(conf['IPV6INIT']).to eq('yes')
+      expect(conf['DHCPV6C']).to eq('no')
+    end
+
+    it 'raises error when given a bad address' do
+      expect { dhcp_interface.address6 = '1::1::1' }.to raise_error(ArgumentError)
+    end
+  end
+
   describe "#gateway=" do
     it "sets the gateway address" do
       address = "192.168.1.1"
@@ -112,6 +128,14 @@ EOF
     end
   end
 
+  describe '#gateway6=' do
+    it 'sets the default gateway for IPv6' do
+      address = 'fe80::1/64'
+      dhcp_interface.gateway6 = address
+      expect(dhcp_interface.interface_config['IPV6_DEFAULTGW']).to eq(address)
+    end
+  end
+
   describe "#netmask=" do
     it "sets the sub-net mask" do
       mask = "255.255.255.0"
@@ -185,6 +209,17 @@ EOF
     end
   end
 
+  describe '#enable_dhcp6' do
+    it 'sets the correct configuration' do
+      [static_interface, dhcp_interface].each do |interface|
+        interface.enable_dhcp6
+        conf = interface.interface_config
+        expect(conf).to include('IPV6INIT' => 'yes', 'DHCPV6C' => 'yes')
+        expect(conf.keys).not_to include('IPV6ADDR', 'IPV6_DEFAULTGW')
+      end
+    end
+  end
+
   describe "#apply_static" do
     it "sets the correct configuration" do
       expect(dhcp_interface).to receive(:save)
@@ -201,6 +236,16 @@ EOF
     end
   end
 
+  describe '#apply_static6' do
+    it 'sets the static IPv6 configuration' do
+      expect(dhcp_interface).to receive(:save)
+      dhcp_interface.apply_static6('d:e:a:d:b:e:e:f', 127, 'd:e:a:d::/64', ['d:e:a:d::'])
+      conf = dhcp_interface.interface_config
+      expect(conf).to include('BOOTPROTO' => 'static', 'IPV6INIT' => 'yes', 'DHCPV6C' => 'no',
+                              'IPV6ADDR' => 'd:e:a:d:b:e:e:f/127', 'IPV6_DEFAULTGW' => 'd:e:a:d::/64')
+    end
+  end
+
   describe "#save" do
     let(:iface_file) { Pathname.new("/etc/sysconfig/network-scripts/ifcfg-#{device_name}") }
 

data/spec/network_interface_spec.rb

@@ -65,7 +65,12 @@ describe LinuxAdmin::NetworkInterface do
 
     IP_ROUTE_ARGS = [
       LinuxAdmin::Common.cmd("ip"),
-      :params => %w(route)
+      :params => ['-4', 'route']
+    ]
+
+    IP6_ROUTE_ARGS = [
+      LinuxAdmin::Common.cmd("ip"),
+      :params => ['-6', 'route']
     ]
 
     IFUP_ARGS = [
@@ -101,6 +106,16 @@ IP_OUT
     IP_ROUTE_OUT = <<-IP_OUT
 default via 192.168.1.1 dev eth0  proto static  metric 100
 192.168.1.0/24 dev eth0  proto kernel  scope link  src 192.168.1.9  metric 100
+IP_OUT
+    IP6_ROUTE_OUT = <<-IP_OUT
+default via d:e:a:d:b:e:e:f dev eth0  proto static  metric 100
+fc00:dead:beef:a::/64 dev virbr1  proto kernel  metric 256 linkdown  pref medium
+fe80::/64 dev eth0  proto kernel  scope link metric 100
+IP_OUT
+
+    IP_NONE_ADDR_OUT = <<-IP_OUT.freeze
+2: eth0: <BROADCAST,MULTICAST> mtu 1500 qdisc fq_codel master virbr1 state DOWN group default qlen 1000
+    link/ether 52:54:00:ce:b4:f4 brd ff:ff:ff:ff:ff:ff
 IP_OUT
 
     subject(:subj) do
@@ -109,6 +124,7 @@ IP_OUT
 
       allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP_ADDR_OUT, 0))
       allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
+      allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
       described_class.new("eth0")
     end
 
@@ -118,6 +134,17 @@ IP_OUT
 
       allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP6_ADDR_OUT, 0))
       allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
+      allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
+      described_class.new("eth0")
+    end
+
+    subject(:subj_no_net) do
+      allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.generic)
+      described_class.dist_class(true)
+
+      allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP_NONE_ADDR_OUT, 0))
+      allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
+      allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
       described_class.new("eth0")
     end
 
@@ -138,6 +165,7 @@ IP_OUT
         awesome_error = AwesomeSpawn::CommandResultError.new("", nil)
         allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP_ADDR_OUT, 0))
         allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_raise(awesome_error)
+        allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_raise(awesome_error)
         expect { subj.reload }.to raise_error(LinuxAdmin::NetworkInterfaceError)
       end
 
@@ -145,6 +173,7 @@ IP_OUT
         subj6
         allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP6_ADDR_OUT, 0))
         allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
+        allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
         expect { subj.reload }.to_not raise_error
       end
     end
@@ -179,6 +208,10 @@ IP_OUT
       it "returns the correct netmask" do
         expect(subj.netmask).to eq("255.255.255.0")
       end
+
+      it 'does not blow-up, when no ip assigned' do
+        expect(subj_no_net.netmask).to eq(nil)
+      end
     end
 
     describe "#netmask6" do
@@ -195,12 +228,38 @@ IP_OUT
       end
     end
 
+    describe '#prefix' do
+      it 'returns the correct prefix' do
+        expect(subj.prefix).to eq(24)
+      end
+    end
+
+    describe '#prefix6' do
+      it 'returns the correct global prefix length' do
+        expect(subj.prefix6).to eq(96)
+      end
+
+      it 'returns the correct link local prefix length' do
+        expect(subj.prefix6(:link)).to eq(64)
+      end
+
+      it 'raises ArgumentError when given a bad scope' do
+        expect { subj.prefix6(:garbage) }.to raise_error(ArgumentError)
+      end
+    end
+
     describe "#gateway" do
       it "returns the correct gateway address" do
         expect(subj.gateway).to eq("192.168.1.1")
       end
     end
 
+    describe '#gateway6' do
+      it 'returns the correct default gateway for IPv6 routing' do
+        expect(subj.gateway6).to eq('d:e:a:d:b:e:e:f')
+      end
+    end
+
     describe "#start" do
       it "returns true on success" do
         expect(AwesomeSpawn).to receive(:run).with(*IFUP_ARGS).and_return(result("", 0))

data/spec/service/systemd_service_spec.rb

@@ -1,4 +1,6 @@
 describe LinuxAdmin::SystemdService do
+  let(:command) { LinuxAdmin::Common.cmd(:systemctl) }
+
   before do
     @service = described_class.new 'foo'
   end
@@ -6,27 +8,24 @@ describe LinuxAdmin::SystemdService do
   describe "#running?" do
     it "checks service" do
       expect(LinuxAdmin::Common).to receive(:run)
-        .with(LinuxAdmin::Common.cmd(:systemctl),
-              :params => {nil => %w(status foo)}).and_return(double(:exit_status => 0))
+        .with(command, :params => %w(status foo)).and_return(double(:success? => true))
       @service.running?
     end
 
     it "returns true when service is running" do
-      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:success? => true))
       expect(@service).to be_running
     end
 
     it "returns false when service is not running" do
-      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:success? => false))
       expect(@service).not_to be_running
     end
   end
 
   describe "#enable" do
     it "enables service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:systemctl),
-              :params => {nil => %w(enable foo)})
+      expect(LinuxAdmin::Common).to receive(:run!) .with(command, :params => %w(enable foo))
       @service.enable
     end
 
@@ -38,9 +37,7 @@ describe LinuxAdmin::SystemdService do
 
   describe "#disable" do
     it "disables service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:systemctl),
-              :params => {nil => %w(disable foo)})
+      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(disable foo))
       @service.disable
     end
 
@@ -52,9 +49,7 @@ describe LinuxAdmin::SystemdService do
 
   describe "#start" do
     it "starts service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:systemctl),
-              :params => {nil => %w(start foo)})
+      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(start foo))
       @service.start
     end
 
@@ -66,9 +61,7 @@ describe LinuxAdmin::SystemdService do
 
   describe "#stop" do
     it "stops service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:systemctl),
-              :params => {nil => %w(stop foo)})
+      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(stop foo))
       @service.stop
     end
 
@@ -80,9 +73,7 @@ describe LinuxAdmin::SystemdService do
 
   describe "#restart" do
     it "restarts service" do
-      expect(LinuxAdmin::Common).to receive(:run)
-        .with(LinuxAdmin::Common.cmd(:systemctl),
-              :params => {nil => %w(restart foo)}).and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run).with(command, :params => %w(restart foo)).and_return(double(:exit_status => 0))
       @service.restart
     end
 
@@ -101,8 +92,7 @@ describe LinuxAdmin::SystemdService do
 
   describe "#reload" do
     it "reloads service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:systemctl), :params => %w(reload foo))
+      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(reload foo))
       expect(@service.reload).to eq(@service)
     end
   end
@@ -111,9 +101,33 @@ describe LinuxAdmin::SystemdService do
     it "returns the service status" do
       status = "service status here"
       expect(LinuxAdmin::Common).to receive(:run)
-        .with(LinuxAdmin::Common.cmd(:systemctl),
-              :params => %w(status foo)).and_return(double(:output => status))
+        .with(command, :params => %w(status foo)).and_return(double(:output => status))
       expect(@service.status).to eq(status)
     end
   end
+
+  describe "#show" do
+    it "returns a hash of runtime information" do
+      output = <<-EOS
+MainPID=29189
+ExecMainStartTimestamp=Wed 2017-02-08 13:49:57 EST
+ExecStart={ path=/bin/sh ; argv[]=/bin/sh -c /bin/evmserver.sh start ; status=0/0 }
+ExecStop={ path=/bin/sh ; argv[]=/bin/sh -c /bin/evmserver.sh stop ; status=0/0 }
+ControlGroup=/system.slice/evmserverd.service
+MemoryCurrent=2865373184
+EOS
+
+      hash = {
+        "MainPID"                => 29_189,
+        "ExecMainStartTimestamp" => Time.new(2017, 2, 8, 13, 49, 57, "-05:00"),
+        "ExecStart"              => {"path" => "/bin/sh", "argv[]" => "/bin/sh -c /bin/evmserver.sh start", "status" => "0/0"},
+        "ExecStop"               => {"path" => "/bin/sh", "argv[]" => "/bin/sh -c /bin/evmserver.sh stop", "status" => "0/0"},
+        "ControlGroup"           => "/system.slice/evmserverd.service",
+        "MemoryCurrent"          => 2_865_373_184
+      }
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(command, :params => %w(show foo)).and_return(double(:output => output))
+      expect(@service.show).to eq(hash)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: linux_admin
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Brandon Dunne
@@ -20,7 +20,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-31 00:00:00.000000000 Z
+date: 2017-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -140,14 +140,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.8
 - !ruby/object:Gem::Dependency
   name: openscap
   requirement: !ruby/object:Gem::Requirement