rcm

1) #!/usr/bin/ruby
2) 

3) require_relative 'objects/rcm_file'
4) require_relative 'objects/rcm_package'
5) require_relative 'objects/rcm_service'
6) require_relative 'managers/rcm_package_manager'

7) require_relative 'managers/rcm_file_manager'
8) require_relative 'managers/rcm_service_manager'
9) require_relative 'rcm_utils'

10) require 'yaml'

11) require 'logger'

12) 
13) module RCM

14)   PACKAGES = 'packages'.freeze
15)   FILES = 'files'.freeze
16)   SERVICES = 'services'.freeze
17)   VALID_LOG_LEVELS = %w(fatal error info debug).freeze
18)   RCM_ENV = ENV.fetch('ENVIRONMENT', '')

19) 
20)   @@wanted = {

21)     PACKAGES => {},
22)     FILES => {},
23)     SERVICES => {}

24)   }
25) 
26)   @@got = {

27)     PACKAGES => {},
28)     FILES => {},
29)     SERVICES => {}

30)   }
31) 

32)   @@crackalackin = {

33)     PACKAGES => [],
34)     FILES => [],
35)     SERVICES => []

36)   }
37) 

38)   @@logger = ::Logger.new(STDOUT)
39) 
40)   @@pkg_mgr = ::RCM::Apt.new(@@logger)
41)   @@file_mgr = ::RCM::FileManager.new(@@logger)
42)   @@svc_mgr = ::RCM::ServiceManager.new(@@logger)
43) 
44)   def self.configure_logger
45)     # Can be exposed as settings but was expanding the scope as this
46)     # object will need to be passed to all other objects
47)     @@logger.level = ::Logger::DEBUG
48)     @@logger.progname = 'rcm'
49)   end

50) 
51)   def self.parse_packages(markup)

52)     @@logger.info("Environment = #{RCM_ENV}")
53)     @@pkg_mgr.update unless RCM_ENV == 'dev'
54) 

55)     markup.each do |d|
56)       # ensure package version exists, if mentioned.
57)       version = d.fetch('version', '')
58)       desired_state = d.fetch('desired_state', ::RCM::Package::INSTALLED)
59) 
60)       valid_package_states = [::RCM::Package::INSTALLED, ::RCM::Package::REMOVED]
61) 
62)       if (valid_package_states & [desired_state]).empty?
63)         raise "Unknown desired_state: #{desired_state}. Valid states: #{valid_package_states.join(', ')}"
64)       end

65) 

66)       unless version.empty?
67)         available_versions = @@pkg_mgr.get_versions(d['name'])
68)         if (available_versions & [version]).empty?
69)           raise "\n\n#{d['name']} = #{version} is not available.\nAvailable versions: #{available_versions.join(', ')}"
70)         end
71)       end
72)       p = RCM::Package.new(d['name'], version, desired_state)
73)       @@wanted[PACKAGES][d['name']] = p
74)     end

75)   end
76) 

77)   def self.parse_files(markup)

78)     valid_file_states = [::RCM::File::PRESENT, ::RCM::File::ABSENT]

79)     markup.each do |d|

80)       raise "\n\nFile state can only be one of #{valid_file_states.join (', ')}" if (valid_file_states | [d['desired_state']]).empty?
81)       raise "\n\n'#{d['local_file']}' is not readable.\n\n" if d['desired_state'] == ::RCM::File::PRESENT && !::File.readable?(d['local_file'])
82)       f = RCM::File.new(d['path'], d['owner'], d['group'], d['mode'], d['local_file'], d['desired_state'])

83)       @@wanted[FILES][d['path']] = f
84)     end
85)   end
86) 
87)   def self.parse_services(markup)
88)     pkgs = @@wanted[PACKAGES]
89)     files = @@wanted[FILES]
90)     file_dependencies = {}
91)     package_dependencies = {}
92)     markup.each do |d|
93)       dependencies = d.fetch('dependencies', {})

94)       dependencies.each do |values|
95)         values.each do |dep_type, dep|
96)           case dep_type
97)           when PACKAGES
98)             dep.each do |pkg_definition|
99)               pkg_name = pkg_definition['name']
100)               raise "\n\nPlease ensure #{pkg_name} is managed by this program before adding it as a dependency.\n\n" unless pkgs.key?(pkg_name)
101)               p = pkgs[pkg_name]
102)               package_dependencies[pkg_name] = p
103)             end
104)           when FILES
105)             dep.each do |file_defnition|
106)               path = file_defnition['path']
107)               raise "\n\nPlease ensure #{path} is managed by this program before adding it as a dependency.\n\n" unless files.key?(path)
108) 
109)               f = files[path]
110)               file_dependencies[path] = f
111)             end
112)           end

113)         end

114) 

115)       end
116)       s = RCM::Service.new(d['name'], file_dependencies, package_dependencies)
117)       @@wanted[SERVICES][d['name']] = s
118)     end
119)   end

120) 

121)   def self.whachuwant # or parse_config

122)     # Consume config from YAML, and convert it to usable objects in @@wanted.

123)     config_file = RCM_ENV.empty? ? 'config.yaml' : "config_#{RCM_ENV}.yaml"

124) 

125)     raise "#{config_file} not found." unless ::File.readable?(config_file)
126) 
127)     config = YAML.load_file(config_file)

128)     config.each do |yaml_objects|

129)       yaml_objects.each do |collection, resource_definition|
130)         case collection

131)         when PACKAGES

132)           parse_packages(resource_definition)

133) 
134)         when FILES

135)           parse_files(resource_definition)

136) 

137)         when SERVICES

138)           parse_services(resource_definition)

139)         end
140)       end
141)     end
142) 
143)   end
144) 

145)   def self.whachugot # or get_current_state

146)     @@got[PACKAGES] = @@pkg_mgr.get_current_state(@@wanted[PACKAGES])
147)     @@got[FILES] = @@file_mgr.get_current_state(@@wanted[FILES])
148)     # @@got[SERVICES] = @@svc_mgr.get_current_state(@@wanted[SERVICES])

149)   end
150) 

151)   def self.converge_packages

152)     @@wanted[PACKAGES].each do |pkg_name, pkg_obj|
153)       current_pkg = @@got[PACKAGES][pkg_name]
154) 

155)       if current_pkg == pkg_obj
156)         @@logger.info("#{pkg_name} is in expected state.")
157)         next
158)       end

159) 

160)       @@logger.debug('Missing package:' + pkg_name)
161)       if current_pkg.version != pkg_obj.version && current_pkg.state == ::RCM::Package::INSTALLED
162)         # Wrong version is installed. Remove current version and install the correct one.
163)         # Not the best way to go about it... but we are not implementing a legit solution.
164)         @logger.debug("#{current_pkg.name}=#{current_pkg.version} is installed. Uninstalling first.")
165)         @@pkg_mgr.remove(pkg_obj)
166)         @@pkg_mgr.install(pkg_obj)
167)       elsif current_pkg.state == ::RCM::Package::REMOVED
168)         @@pkg_mgr.install(pkg_obj)
169)       end

170)     end

171) 

172)   end
173) 

174)   def self.converge_files

175)     @@wanted[FILES].each do |path, file_obj|
176)       file_on_fs = @@got[FILES][path]

177) 

178)       if file_on_fs.state == ::RCM::File::PRESENT && file_obj.state == ::RCM::File::ABSENT
179)         @@logger.info("#{path} is present on disk when it should not be. Removing...")
180)         @@file_mgr.remove(file_obj)

181)         next
182)       end
183) 

184)       if file_on_fs == file_obj
185)         @@logger.info("#{path} is in expected state (#{file_on_fs.state}).")
186)         next

187)       end

188) 

189)       @@logger.info("#{path} is not present on disk.")
190)       status = @@file_mgr.copy(file_obj)
191)       @@file_mgr.apply_attributes(file_obj) if status == 0
192) 

193)     end

194)   end
195) 

196)   def self.restart_services_if_needed
197)     @@wanted[SERVICES].values.each do |svc_obj|

198)       @@svc_mgr.restart(svc_obj) if @@svc_mgr.dependencies_changed?(svc_obj)

199)     end

200)   end

201) 
202)   def main

203)     configure_logger
204)     whachuwant
205)     whachugot
206)     converge_packages
207)     converge_files
208)     restart_services_if_needed

209)   end

210) 

211)   module_function :main

212) end
213) 

214) RCM.main