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)   @logger = ::Logger.new(STDOUT)

33) 

34)   @pkg_mgr = ::RCM::Apt.new(@logger)
35)   @file_mgr = ::RCM::FileManager.new(@logger)
36)   @svc_mgr = ::RCM::ServiceManager.new(@logger)

37) 
38)   def self.configure_logger
39)     # Can be exposed as settings but was expanding the scope as this
40)     # object will need to be passed to all other objects

41)     @logger.level = ::Logger::DEBUG
42)     @logger.progname = 'rcm'

43)   end

44) 
45)   def self.parse_packages(markup)

46)     @logger.info("Environment = #{RCM_ENV}")
47)     @pkg_mgr.update unless RCM_ENV == 'dev'

48) 

49)     markup.each do |d|
50)       # ensure package version exists, if mentioned.
51)       version = d.fetch('version', '')
52)       desired_state = d.fetch('desired_state', ::RCM::Package::INSTALLED)
53) 
54)       valid_package_states = [::RCM::Package::INSTALLED, ::RCM::Package::REMOVED]
55) 
56)       if (valid_package_states & [desired_state]).empty?
57)         raise "Unknown desired_state: #{desired_state}. Valid states: #{valid_package_states.join(', ')}"
58)       end

59) 

60)       unless version.empty?

61)         available_versions = @pkg_mgr.get_versions(d['name'])

62)         if (available_versions & [version]).empty?
63)           raise "\n\n#{d['name']} = #{version} is not available.\nAvailable versions: #{available_versions.join(', ')}"
64)         end
65)       end
66)       p = RCM::Package.new(d['name'], version, desired_state)

67)       @wanted[PACKAGES][d['name']] = p

68)     end

69)   end
70) 

71)   def self.parse_files(markup)

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

73)     markup.each do |d|

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

77)       @wanted[FILES][d['path']] = f

78)     end
79)   end
80) 
81)   def self.parse_services(markup)

82)     pkgs = @wanted[PACKAGES]
83)     files = @wanted[FILES]

84)     file_dependencies = {}
85)     package_dependencies = {}
86)     markup.each do |d|
87)       dependencies = d.fetch('dependencies', {})

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

107)         end

108) 

109)       end
110)       s = RCM::Service.new(d['name'], file_dependencies, package_dependencies)

111)       @wanted[SERVICES][d['name']] = s

112)     end
113)   end

114) 

115)   def self.whachuwant # or parse_config

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

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

118) 

119)     raise "#{config_file} not found." unless ::File.readable?(config_file)
120) 
121)     config = YAML.load_file(config_file)

122)     config.each do |yaml_objects|

123)       yaml_objects.each do |collection, resource_definition|
124)         case collection

125)         when PACKAGES

126)           parse_packages(resource_definition)

127) 
128)         when FILES

129)           parse_files(resource_definition)

130) 

131)         when SERVICES

132)           parse_services(resource_definition)

133)         end
134)       end
135)     end
136) 
137)   end
138) 

139)   def self.converge_packages

140)     # We'll install them in one go (minor optimization)
141)     missing_packages = []
142) 

143)     @wanted[PACKAGES].each do |pkg_name, pkg_obj|
144)       current_pkg = @got[PACKAGES][pkg_name]

145) 

146)       if current_pkg == pkg_obj

147)         @logger.info("#{pkg_name} is in expected state.")

148)         next
149)       end

150) 

151)       if current_pkg.version != pkg_obj.version && current_pkg.state == ::RCM::Package::INSTALLED
152)         # Wrong version is installed. Remove current version and install the correct one.
153)         # Not the best way to go about it... but we are not implementing a legit solution.
154)         @logger.debug("#{current_pkg.name}=#{current_pkg.version} is installed. Uninstalling first.")

155)         @pkg_mgr.remove(pkg_obj)

156)         missing_packages.push(pkg_obj)

157)       elsif current_pkg.state == ::RCM::Package::REMOVED

158)         missing_packages.push(pkg_obj)

159)       end

160)     end

161) 

162)     @pkg_mgr.install(missing_packages)
163) 

164)   end
165) 

166)   def self.converge_files

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

169) 

170)       if file_on_fs.state == ::RCM::File::PRESENT && file_obj.state == ::RCM::File::ABSENT

171)         @logger.info("#{path} is present on disk when it should not be. Removing...")
172)         @file_mgr.remove(file_obj)

173)         next
174)       end
175) 

176)       if file_on_fs == file_obj

177)         @logger.info("#{path} is in expected state (#{file_on_fs.state}).")

178)         next

179)       end

180) 

181)       @logger.info("#{path} is not in expected state on disk.")

182)       status = @file_mgr.copy(file_obj)
183)       @file_mgr.apply_attributes(file_obj) if status == 0

184) 

185)     end

186)   end
187) 

188)   def self.restart_services_if_needed

189)     @wanted[SERVICES].values.each do |svc_obj|
190)       @svc_mgr.restart(svc_obj) if @svc_mgr.dependencies_changed?(svc_obj)

191)     end

192)   end

193) 
194)   def main

195)     configure_logger
196)     whachuwant

197)     # Installing packages creates file that we want to delete.
198)     # So finish managing packages and then deal with files.
199)     @got[PACKAGES] = @pkg_mgr.get_current_state(@wanted[PACKAGES])

200)     converge_packages

201)     @got[FILES] = @file_mgr.get_current_state(@wanted[FILES])

202)     converge_files
203)     restart_services_if_needed

204)   end

205) 

206)   module_function :main

207) end
208) 

209) RCM.main