rcm

1) require_relative '../rcm_utils'
2) 
3) module RCM
4)   class Apt
5)     APT_GET = '/usr/bin/apt-get'.freeze
6)     DPKG_QUERY = '/usr/bin/dpkg-query'.freeze
7)     APT_CACHE = '/usr/bin/apt-cache'.freeze

8)     APT_PARTIAL_DIR = '/var/lib/apt/lists/partial'.freeze
9) 
10)     def initialize(logger)
11)       @logger = logger
12)     end

13) 

14)     def update

15)       @logger.info('Updating apt cache.')
16)       unless ::File.readable?(APT_PARTIAL_DIR)
17)         @logger.warn('Skipping apt cache update as we are not running with right privilege.')
18)         return
19)       end

20)       status = ::RCM.cmd("#{APT_GET} update")

21)       unless status[:exit_code] == 0
22)         @logger.warn("Updating apt cache failed. \n\n#{status[:error]}\n\nstdout:\n#{status[:output]}")
23)       end

24)     end
25) 
26)     def status(pkg_name)
27)       ::RCM.cmd("#{DPKG_QUERY} --status #{pkg_name}")
28)     end
29) 

30)     def install(pkgs)

31)       raise "\n\nPlease ensure you are running with root privileges\n\n" unless ::File.readable?(APT_PARTIAL_DIR)
32) 

33)       # If we only get one obejct, add to it an array and process it like that
34)       packages = pkgs.is_a?(::RCM::Package) ? [pkgs] : pkgs

35) 

36)       @logger.info("Installing #{packages.join(', ')}")

37)       # Construct string of packages to install in one go.
38)       pkgs_string = ''

39)       packages.each do |pkg|
40)         version_string = pkg.version.empty? ? '' : "=#{pkg.version}"

41)         pkgs_string += "#{pkg.name}#{version_string} "
42)       end
43) 

44)       cmd_string = "#{APT_GET} install --yes #{pkgs_string}"
45)       status = ::RCM.cmd(cmd_string)
46)       if status[:exit_code] == 0
47)         @logger.info("Success: #{cmd_string}.")
48)         # Update state
49)         packages.each { |pkg| pkg.changed = true; pkg.state = ::RCM::Package::INSTALLED }
50)       else
51)         @logger.error("Failed: #{cmd_string}\n\nstderr:\n#{status[:error]}\n\nstdout:\n#{status[:output]}")
52)       end

53)     end
54) 
55)     def get_versions(pkg_name)
56)       name = ''
57)       if pkg_name.is_a?(String)
58)         name = pkg_name
59)       elsif pkg_name.is_a?(::RCM::Package)
60)         name = pkg_name.name
61)       end
62)       status = ::RCM.cmd("#{APT_CACHE} madison #{name}")
63)       return [] if !status[:output] || status[:output] =~ /Unable to locate package/
64) 
65)       # Collect all versions by splitting on new line, and then collecting second
66)       # field from every line with delimiter ' | '
67)       available_versions = status[:output].split("\n").collect { |l| l.split(' | ')[1] }
68)       available_versions.uniq
69)     end
70) 

71)     def remove(pkg)

72)       raise "\n\nPlease ensure you are running with root privileges\n\n" unless ::File.readable?(APT_PARTIAL_DIR)
73) 

74)       @logger.info("Uninstalling #{pkg.name}.")

75)       # Remove is idempotent and returns with success even if package is not installed.

76)       status = ::RCM.cmd("#{APT_GET} remove --yes #{pkg.name}")
77)       @logger.debug("\nstderr:\n#{status[:error]}\n\nstdout:\n#{status[:output]}")
78)       raise "Removing #{pkg.name} failed!" unless status[:exit_code] == 0
79)       pkg.changed = true
80)       pkg.state = ::RCM::Package::REMOVED

81)     end

82) 
83)     def get_current_state(wanted_packages)
84)       got = {}
85)       wanted_packages.each do |name, p|
86)         state = ::RCM::Package::REMOVED
87)         version = 'idk'
88)         status = status(p.name)
89) 
90)         if status[:exit_code] == 0

91)           state = ::RCM::Package::INSTALLED if status[:output] =~ /.+ok installed/

92)           version = /Version: (?<version>\d+.+)/.match(status[:output])[:version]
93)         end
94) 
95)         current_pkg = ::RCM::Package.new(name, version, state)
96) 
97)         got[name] = current_pkg
98)       end
99) 
100)       got
101)     end