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)     markup.each do |d|
79)       raise "\n\n'#{d['local_file']}' is not readable.\n\n" unless ::File.readable?(d['local_file'])
80)       f = RCM::File.new(d['path'], d['owner'], d['group'], d['mode'], d['local_file'])
81)       @@wanted[FILES][d['path']] = f
82)     end
83)   end
84) 
85)   def self.parse_services(markup)
86)     pkgs = @@wanted[PACKAGES]
87)     files = @@wanted[FILES]
88)     file_dependencies = {}
89)     package_dependencies = {}
90)     markup.each do |d|
91)       dependencies = d.fetch('dependencies', {})
92)       dependencies.each do |dep|
93)         case dep
94)         when PACKAGES
95)           raise "\n\nPlease ensure #{dep['name']} is managed by this program before adding it as a dependency.\n\n" unless pkgs.key?(dep['name'])
96)           p = pkgs[dep['name']]
97)           package_dependencies[p.name] = p
98)         when FILES
99)           raise "\n\nPlease ensure #{dep['path']} is managed by this program before adding it as a dependency.\n\n" unless files.key?(dep['path'])
100) 
101)           f = files[dep['path']]
102)           file_dependencies[f.path] = f
103)         end
104)       end
105)       s = RCM::Service.new(d['name'], file_dependencies, package_dependencies)
106)       @@wanted[SERVICES][d['name']] = s
107)     end
108)   end

109) 

110)   def whachuwant # or parse_config

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

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

113) 

114)     raise "#{config_file} not found." unless ::File.readable?(config_file)
115) 
116)     config = YAML.load_file(config_file)

117)     config.each do |yaml_objects|

118)       yaml_objects.each do |collection, resource_definition|
119)         case collection

120)         when PACKAGES

121)           parse_packages(resource_definition)

122) 
123)         when FILES

124)           parse_files(resource_definition)

125) 

126)         when SERVICES

127)           parse_services(resource_definition)

128)         end
129)       end
130)     end
131) 
132)   end
133) 

134)   def whachugot # or get_current_state
135)     @@got[PACKAGES] = @@pkg_mgr.get_current_state(@@wanted[PACKAGES])
136)     @@got[FILES] = @@file_mgr.get_current_state(@@wanted[FILES])
137)     # @@got[SERVICES] = @@svc_mgr.get_current_state(@@wanted[SERVICES])

138)   end
139) 

140)   def crackalackin_packages

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

144)       next if current_pkg == pkg_obj

145) 
146)       # Set the version correctly
147)       current_pkg.version = pkg_obj.version
148)       @@crackalackin[PACKAGES].push(current_pkg)
149)     end

150)     @@logger.debug('Missing packages:' + @@crackalackin[PACKAGES].join("\n"))
151)   end
152) 
153)   def crackalackin_files
154)     @@wanted[FILES].each do |path, file_obj|
155)       file_on_fs = @@got[FILES][path]

156) 

157)       next if file_on_fs == file_obj
158) 
159)       # Set the version correctly
160)       @@crackalackin[FILES].push(file_obj)
161)     end
162)     @@logger.debug('Missing files:' + @@crackalackin[FILES].join("\n"))
163)     puts @@crackalackin[FILES]

164)   end
165) 
166)   def cracka_stop_lackin()
167)     puts 'not implemented'
168)   end

169) 
170)   def main
171)     self.configure_logger
172)   end
173)   module_function :whachuwant, :whachugot, :crackalackin_packages, :crackalackin_files,
174)                   :cracka_stop_lackin, :main

175) 
176) end
177) 

178) RCM.main

179) RCM.whachuwant

180) RCM.whachugot
181) RCM.crackalackin_packages