rcm

@@ -1,3 +1,7 @@

+- logging:

+  - level: debug

+    file: STDOUT

+

 - packages:

   - name: apache2

     version: 2.4.18-2ubuntu3.8

@@ -0,0 +1,159 @@

+module RCM

+  class ConfigManager

+    PACKAGES = 'packages'.freeze

+    FILES = 'files'.freeze

+    SERVICES = 'services'.freeze

+    LOGGING = 'logging'.freeze

+

+    @wanted = {

+      PACKAGES => {},

+      FILES => {},

+      SERVICES => {}

+    }

+

+    @logger = nil

+    @env = ''

+

+    VALID_LOG_LEVELS = %w[fatal error info debug].freeze

+

+    def initialize()

+      @env = ENV.fetch('ENVIRONMENT', '')

+      config_file = @env.empty? ? 'config.yaml' : "config_#{@env}.yaml"

+      

+      raise "#{config_file} not found." unless ::File.readable?(config_file)

+

+      config = YAML.load_file(config_file)

+      config.each do |yaml_objects|

+        yaml_objects.each do |collection, resource_definition|

+          case collection

+          when LOGGING

+            configure_logging(resource_definition)

+

+          when PACKAGES

+            parse_packages(resource_definition)

+

+          when FILES

+            parse_files(resource_definition)

+

+          when SERVICES

+            parse_services(resource_definition)

+          end # of case

+        end # of iterating over yaml_objects

+      end # of iterating over config

+    end

+

+    def logger

+      @logger

+    end

+

+    def packages

+      @wanted[PACKAGES]

+    end

+

+    def files

+      @wanted[FILES]

+    end

+

+    def services

+      @wanted[SERVICES]

+    end

+

+    def configure_logging(markup)

+      file = markup[0]['file']

+      device = ''

+      level = markup[0]['level']

+

+      if (VALID_LOG_LEVELS & [level]).empty?

+        raise "Invalid log level '#{level}'. Valid log levels are: #{VALID_LOG_LEVELS.join(', ')}" 

+      end

+

+      case file

+      when 'STDOUT'

+        device = STDOUT

+

+      when 'STDERR'

+        device = STDERR

+

+      else

+        # treat whatever is written as file

+        device = ::File.open(file, 'a+')

+      end

+

+      @logger = ::Logger.new(device)

+      @logger.level = level

+      @logger.progname = 'rcm'

+      @logger

+    end

+

+    def parse_packages(markup)

+      @logger.info("Environment = #{@env}")

+

+      markup.each do |d|

+        # ensure package version exists, if mentioned.

+        version = d.fetch('version', '')

+        desired_state = d.fetch('desired_state', ::RCM::Package::INSTALLED)

+

+        valid_package_states = [::RCM::Package::INSTALLED, ::RCM::Package::REMOVED]

+

+        if (valid_package_states & [desired_state]).empty?

+          raise "Unknown desired_state: #{desired_state}. Valid states: #{valid_package_states.join(', ')}"

+        end

+

+        unless version.empty?

+          # Convenience... check if the version mentioned in config is correct.

+          pkg_mgr = ::RCM::Apt.new(@logger)

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

+          if (available_versions & [version]).empty?

+            raise "\n\n#{d['name']} = #{version} is not available.\nAvailable versions: #{available_versions.join(', ')}"

+          end

+        end

+        p = RCM::Package.new(d['name'], version, desired_state)

+        @wanted[PACKAGES][d['name']] = p

+      end

+    end

+

+    def parse_files(markup)

+      valid_file_states = [::RCM::File::PRESENT, ::RCM::File::ABSENT]

+      markup.each do |d|

+        raise "\n\nFile state can only be one of #{valid_file_states.join(', ')}" if (valid_file_states | [d['desired_state']]).empty?

+        raise "\n\n'#{d['local_file']}' is not readable.\n\n" if d['desired_state'] == ::RCM::File::PRESENT && !::File.readable?(d['local_file'])

+        f = RCM::File.new(d['path'], d['owner'], d['group'], d['mode'], d['local_file'], d['desired_state'])

+        @wanted[FILES][d['path']] = f

+      end

+    end

+

+    def parse_services(markup)

+      pkgs = @wanted[PACKAGES]

+      files = @wanted[FILES]

+      file_dependencies = {}

+      package_dependencies = {}

+      markup.each do |d|

+        dependencies = d.fetch('dependencies', {})

+        dependencies.each do |values|

+          values.each do |dep_type, dep|

+            case dep_type

+            when PACKAGES

+              dep.each do |pkg_definition|

+                pkg_name = pkg_definition['name']

+                raise "\n\nPlease ensure #{pkg_name} is managed by this program before adding it as a dependency.\n\n" unless pkgs.key?(pkg_name)

+                p = pkgs[pkg_name]

+                package_dependencies[pkg_name] = p

+              end

+            when FILES

+              dep.each do |file_defnition|

+                path = file_defnition['path']

+                raise "\n\nPlease ensure #{path} is managed by this program before adding it as a dependency.\n\n" unless files.key?(path)

+

+                f = files[path]

+                file_dependencies[path] = f

+              end

+            end

+          end

+        end

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

+        @wanted[SERVICES][d['name']] = s

+      end

+    end

+

+  end # of class ConfigManager

+end # module

@@ -3,6 +3,7 @@

 require_relative 'objects/rcm_file'

 require_relative 'objects/rcm_package'

 require_relative 'objects/rcm_service'

+require_relative 'managers/rcm_config_manager'

 require_relative 'managers/rcm_package_manager'

 require_relative 'managers/rcm_file_manager'

 require_relative 'managers/rcm_service_manager'

@@ -11,137 +12,27 @@ require 'yaml'

 require 'logger'

 module RCM

-  PACKAGES = 'packages'.freeze

-  FILES = 'files'.freeze

-  SERVICES = 'services'.freeze

-  VALID_LOG_LEVELS = %w(fatal error info debug).freeze

-  RCM_ENV = ENV.fetch('ENVIRONMENT', '')

-

-  @wanted = {

-    PACKAGES => {},

-    FILES => {},

-    SERVICES => {}

-  }

+  @config_mgr = ::RCM::ConfigManager.new()

   @got = {

-    PACKAGES => {},

-    FILES => {},

-    SERVICES => {}

+    ::RCM::ConfigManager::PACKAGES => {},

+    ::RCM::ConfigManager::FILES => {},

+    ::RCM::ConfigManager::SERVICES => {}

   }

-  @logger = ::Logger.new(STDOUT)

-

+  @logger = @config_mgr.logger

   @pkg_mgr = ::RCM::Apt.new(@logger)

   @file_mgr = ::RCM::FileManager.new(@logger)

   @svc_mgr = ::RCM::ServiceManager.new(@logger)

-  def self.configure_logger

-    # Can be exposed as settings but was expanding the scope as this

-    # object will need to be passed to all other objects

-    @logger.level = ::Logger::DEBUG

-    @logger.progname = 'rcm'

-  end

-

-  def self.parse_packages(markup)

-    @logger.info("Environment = #{RCM_ENV}")

-    @pkg_mgr.update unless RCM_ENV == 'dev'

-

-    markup.each do |d|

-      # ensure package version exists, if mentioned.

-      version = d.fetch('version', '')

-      desired_state = d.fetch('desired_state', ::RCM::Package::INSTALLED)

-

-      valid_package_states = [::RCM::Package::INSTALLED, ::RCM::Package::REMOVED]

-

-      if (valid_package_states & [desired_state]).empty?

-        raise "Unknown desired_state: #{desired_state}. Valid states: #{valid_package_states.join(', ')}"

-      end

-

-      unless version.empty?

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

-        if (available_versions & [version]).empty?

-          raise "\n\n#{d['name']} = #{version} is not available.\nAvailable versions: #{available_versions.join(', ')}"

-        end

-      end

-      p = RCM::Package.new(d['name'], version, desired_state)

-      @wanted[PACKAGES][d['name']] = p

-    end

-  end

-

-  def self.parse_files(markup)

-    valid_file_states = [::RCM::File::PRESENT, ::RCM::File::ABSENT]

-    markup.each do |d|

-      raise "\n\nFile state can only be one of #{valid_file_states.join (', ')}" if (valid_file_states | [d['desired_state']]).empty?

-      raise "\n\n'#{d['local_file']}' is not readable.\n\n" if d['desired_state'] == ::RCM::File::PRESENT && !::File.readable?(d['local_file'])

-      f = RCM::File.new(d['path'], d['owner'], d['group'], d['mode'], d['local_file'], d['desired_state'])

-      @wanted[FILES][d['path']] = f

-    end

-  end

-

-  def self.parse_services(markup)

-    pkgs = @wanted[PACKAGES]

-    files = @wanted[FILES]

-    file_dependencies = {}

-    package_dependencies = {}

-    markup.each do |d|

-      dependencies = d.fetch('dependencies', {})

-      dependencies.each do |values|

-        values.each do |dep_type, dep|

-          case dep_type

-          when PACKAGES

-            dep.each do |pkg_definition|

-              pkg_name = pkg_definition['name']

-              raise "\n\nPlease ensure #{pkg_name} is managed by this program before adding it as a dependency.\n\n" unless pkgs.key?(pkg_name)

-              p = pkgs[pkg_name]

-              package_dependencies[pkg_name] = p

-            end

-          when FILES

-            dep.each do |file_defnition|

-              path = file_defnition['path']

-              raise "\n\nPlease ensure #{path} is managed by this program before adding it as a dependency.\n\n" unless files.key?(path)

-

-              f = files[path]

-              file_dependencies[path] = f

-            end

-          end

-        end

-

-      end

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

-      @wanted[SERVICES][d['name']] = s

-    end

-  end

-

-  def self.whachuwant # or parse_config

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

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

-

-    raise "#{config_file} not found." unless ::File.readable?(config_file)

-

-    config = YAML.load_file(config_file)

-    config.each do |yaml_objects|

-      yaml_objects.each do |collection, resource_definition|

-        case collection

-        when PACKAGES

-          parse_packages(resource_definition)

-

-        when FILES

-          parse_files(resource_definition)

-

-        when SERVICES

-          parse_services(resource_definition)

-        end

-      end

-    end

-

-  end

-

-  def self.converge_packages

+  def self.converge_packages(current_state_of_packages)

     # We'll install them in one go (minor optimization)

     missing_packages = []

-    @wanted[PACKAGES].each do |pkg_name, pkg_obj|

-      current_pkg = @got[PACKAGES][pkg_name]

+    @pkg_mgr.update unless @env == 'dev'

+

+    @config_mgr.packages.each do |pkg_name, pkg_obj|

+      current_pkg = current_state_of_packages[pkg_name]

       if current_pkg == pkg_obj

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

@@ -160,12 +51,11 @@ module RCM

     end

     @pkg_mgr.install(missing_packages) unless missing_packages.empty?

-

   end

-  def self.converge_files

-    @wanted[FILES].each do |path, file_obj|

-      file_on_fs = @got[FILES][path]

+  def self.converge_files(current_state_of_files)

+    @config_mgr.files.each do |path, file_obj|

+      file_on_fs = current_state_of_files[path]

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

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

@@ -186,20 +75,18 @@ module RCM

   end

   def self.restart_services_if_needed

-    @wanted[SERVICES].values.each do |svc_obj|

+    @config_mgr.services.values.each do |svc_obj|

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

     end

   end

   def main

-    configure_logger

-    whachuwant

     # Installing packages creates file that we want to delete.

     # So finish managing packages and then deal with files.

-    @got[PACKAGES] = @pkg_mgr.get_current_state(@wanted[PACKAGES])

-    converge_packages

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

-    converge_files

+    current_state_of_packages = @pkg_mgr.get_current_state(@config_mgr.packages)

+    converge_packages(current_state_of_packages)

+    current_state_of_files = @file_mgr.get_current_state(@config_mgr.files)

+    converge_files(current_state_of_files)

     restart_services_if_needed

   end