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) 

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

72)     def remove(pkg)

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

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

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

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

82)     end

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

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

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