d-installer 0.4.2

data/lib/dinstaller/questions_manager.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2022] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+module DInstaller
+  # Manager for questions
+  #
+  # Allows to configure callbacks with the actions to perform when adding, deleting or waiting for
+  # questions.
+  class QuestionsManager
+    # @return [Array<Question>]
+    attr_reader :questions
+
+    # Constructor
+    #
+    # @params logger [Logger]
+    def initialize(logger)
+      @logger = logger
+      @questions = []
+      @on_add_callbacks = []
+      @on_delete_callbacks = []
+      @on_wait_callbacks = []
+    end
+
+    # Adds a question
+    #
+    # Callbacks are called after adding the question, see {#on_add}.
+    #
+    # @yieldparam question [Question] added question
+    #
+    # @param question [Question]
+    # @return [Boolean] whether the question was added
+    def add(question)
+      return false if include?(question)
+
+      questions << question
+      on_add_callbacks.each { |c| c.call(question) }
+
+      true
+    end
+
+    # Deletes the given question
+    #
+    # Callbacks are called after deleting the question, see {#on_delete}.
+    #
+    # @yieldparam question [Question] deleted question
+    #
+    # @param question [Question]
+    # @return [Boolean] whether the question was deleted
+    def delete(question)
+      return false unless include?(question)
+
+      questions.delete(question)
+      on_delete_callbacks.each { |c| c.call(question) }
+
+      true
+    end
+
+    # Waits until all questions are answered
+    #
+    # Callbacks are periodically called while waiting, see {#on_wait}.
+    def wait
+      logger.info "Waiting for questions to be answered"
+
+      loop do
+        on_wait_callbacks.each(&:call)
+        sleep(0.1)
+        break if questions_answered?
+      end
+    end
+
+    # Registers a callback to be called when a new question is added
+    #
+    # @param block [Proc]
+    def on_add(&block)
+      on_add_callbacks << block
+    end
+
+    # Registers a callback to be called when a question is deleted
+    #
+    # @param block [Proc]
+    def on_delete(&block)
+      on_delete_callbacks << block
+    end
+
+    # Registers a callback to be called while waiting for questions be answered
+    #
+    # @param block [Proc]
+    def on_wait(&block)
+      on_wait_callbacks << block
+    end
+
+  private
+
+    # @return [Logger]
+    attr_reader :logger
+
+    # Callbacks to be called when the a new question is added
+    #
+    # @return [Array<Proc>]
+    attr_reader :on_add_callbacks
+
+    # Callbacks to be called when the a question is deleted
+    #
+    # @return [Array<Proc>]
+    attr_reader :on_delete_callbacks
+
+    # Callbacks to be called when waiting for answers
+    #
+    # @return [Array<Proc>]
+    attr_reader :on_wait_callbacks
+
+    # Whether a question with the same id as the given question is already in the list of questions
+    #
+    # @param question [Question]
+    # @return [Boolean]
+    def include?(question)
+      questions.any? { |q| q.id == question.id }
+    end
+
+    # Whether all questions are already answered
+    #
+    # @return [Boolean]
+    def questions_answered?
+      questions.all?(&:answered?)
+    end
+  end
+end

data/lib/dinstaller/security.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2022] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require "yast"
+require "y2security/lsm"
+require "yast2/execute"
+
+require "dinstaller/config"
+
+# FIXME: monkey patching of security config to not read control.xml and
+# instead use DIinstaller::Config
+# TODO: add ability to set product features in LSM::Base
+module Y2Security
+  module LSM
+    # modified LSM Base class to use dinstaller config
+    class Base
+      def product_feature_settings
+        return @product_feature_settings unless @product_feature_settings.nil?
+
+        value = ::DInstaller::Config.current.data["security"]["available_lsms"][id.to_s]
+        res = if value
+          {
+            selectable:   true,
+            configurable: true,
+            patterns:     (value["patterns"] || []).join(" "),
+            mode:         value["policy"]
+          }
+        else
+          {
+            selectable:   false,
+            configurable: false,
+            patterns:     "",
+            mode:         nil
+          }
+        end
+        @product_feature_settings = res
+      end
+    end
+  end
+end
+
+module DInstaller
+  # Backend class between dbus service and yast code
+  class Security
+    # @return [Logger]
+    attr_reader :logger
+
+    def initialize(logger, config)
+      @config = config
+      @logger = logger
+    end
+
+    def write
+      lsm_config.save
+    end
+
+    def probe
+      selected_lsm = config.data["security"]["lsm"]
+      lsm_config.select(selected_lsm)
+
+      patterns = if selected_lsm.nil?
+        []
+      else
+        lsm_data = config.data["security"]["available_lsms"][selected_lsm]
+        lsm_data["patterns"]
+      end
+      Yast::PackagesProposal.SetResolvables("LSM", :pattern, patterns)
+    end
+
+  private
+
+    attr_reader :config
+
+    def lsm_config
+      Y2Security::LSM::Config.instance
+    end
+  end
+end

data/lib/dinstaller/service_status_recorder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2022] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require "dinstaller/dbus/service_status"
+
+module DInstaller
+  # Allows to record the status of services and to register callbacks to be called when a service
+  # status changes its value
+  class ServiceStatusRecorder
+    def initialize
+      @statuses = {}
+      @on_service_status_change_callbacks = []
+    end
+
+    # Saves the status of the given service and runs the callbacks if the status has changed
+    #
+    # @param service_name [String]
+    # @param status [String] see {ServiceStatus}
+    def save(service_name, status)
+      return if @statuses[service_name] == status
+
+      @statuses[service_name] = status
+      @on_service_status_change_callbacks.each(&:call)
+    end
+
+    # Name of services with busy status
+    #
+    # @return [Array<String>]
+    def busy_services
+      @statuses.select { |_service, status| status == DBus::ServiceStatus::BUSY }.keys
+    end
+
+    # Registers callbacks to be called when saving a new status
+    #
+    # @param block [Proc]
+    def on_service_status_change(&block)
+      @on_service_status_change_callbacks << block
+    end
+  end
+end

data/lib/dinstaller/software.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2021] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require "yast"
+require "fileutils"
+require "dinstaller/package_callbacks"
+require "dinstaller/config"
+require "dinstaller/with_progress"
+require "y2packager/product"
+
+Yast.import "PackageInstallation"
+Yast.import "Pkg"
+Yast.import "Stage"
+
+# YaST specific code lives under this namespace
+module DInstaller
+  # This class is responsible for software handling
+  class Software
+    include WithProgress
+
+    GPG_KEYS_GLOB = "/usr/lib/rpm/gnupg/keys/gpg-*"
+    private_constant :GPG_KEYS_GLOB
+
+    attr_reader :product
+
+    DEFAULT_LANGUAGES = ["en_US"].freeze
+    private_constant :DEFAULT_LANGUAGES
+
+    attr_accessor :languages
+
+    # FIXME: what about defining a Product class?
+    # @return [Array<Array<String,Hash>>] An array containing the product ID and
+    #   additional information in a hash
+    attr_reader :products
+
+    def initialize(config, logger)
+      @config = config
+      @logger = logger
+      @languages = DEFAULT_LANGUAGES
+      @products = @config.data["products"]
+      if @config.multi_product?
+        @product = nil
+      else
+        @product = @products.keys.first # use the available product as default
+        @config.pick_product(@product)
+      end
+    end
+
+    def select_product(name)
+      return if name == @product
+      raise ArgumentError unless @products[name]
+
+      @config.pick_product(name)
+      @product = name
+    end
+
+    def probe
+      logger.info "Probing software"
+
+      store_original_repos
+      Yast::Pkg.SetSolverFlags("ignoreAlreadyRecommended" => false, "onlyRequires" => true)
+
+      # as we use liveDVD with normal like ENV, lets temporary switch to normal to use its repos
+      Yast::Stage.Set("normal")
+
+      start_progress(3)
+      progress.step("Initialize target repositories") { initialize_target_repos }
+      progress.step("Initialize sources") { add_base_repo }
+      progress.step("Making the initial proposal") do
+        proposal = Yast::Packages.Proposal(force_reset = true, reinit = false, _simple = true)
+        logger.info "proposal #{proposal["raw_proposal"]}"
+      end
+
+      Yast::Stage.Set("initial")
+    end
+
+    def initialize_target_repos
+      Yast::Pkg.TargetInitialize("/")
+      import_gpg_keys
+    end
+
+    def propose
+      Yast::Pkg.TargetFinish # ensure that previous target is closed
+      Yast::Pkg.TargetInitialize(Yast::Installation.destdir)
+      Yast::Pkg.TargetLoad
+      Yast::Pkg.SetAdditionalLocales(languages)
+      select_base_product(@config.data["software"]["base_product"])
+
+      add_resolvables
+      proposal = Yast::Packages.Proposal(force_reset = false, reinit = false, _simple = true)
+      logger.info "proposal #{proposal["raw_proposal"]}"
+
+      solve_dependencies
+
+      # do not return proposal hash, so intentional nil here
+      nil
+    end
+
+    def install
+      start_progress(count_packages)
+      PackageCallbacks.setup(count_packages, progress)
+
+      # TODO: error handling
+      commit_result = Yast::PackageInstallation.Commit({})
+
+      if commit_result.nil? || commit_result.empty?
+        logger.error("Commit failed")
+        raise Yast::Pkg.LastError
+      end
+
+      logger.info "Commit result #{commit_result}"
+    end
+
+    # Writes the repositories information to the installed system
+    def finish
+      start_progress(2)
+      progress.step("Writing repositories to the target system") do
+        Yast::Pkg.SourceSaveAll
+        Yast::Pkg.TargetFinish
+        Yast::Pkg.SourceCacheCopyTo(Yast::Installation.destdir)
+      end
+      progress.step("Restoring original repositories") { restore_original_repos }
+    end
+
+    # Determine whether the given tag is provided by the selected packages
+    #
+    # @param tag [String] Tag to search for (package names, requires/provides, or file
+    #   names)
+    # @return [Boolean] true if it is provided; false otherwise
+    def provision_selected?(tag)
+      Yast::Pkg.IsSelected(tag) || Yast::Pkg.IsProvided(tag)
+    end
+
+  private
+
+    # adds resolvables from yaml config for given product
+    def add_resolvables
+      mandatory_patterns = @config.data["software"]["mandatory_patterns"] || []
+      Yast::PackagesProposal.SetResolvables("d-installer", :pattern, mandatory_patterns)
+
+      optional_patterns = @config.data["software"]["optional_patterns"] || []
+      Yast::PackagesProposal.SetResolvables("d-installer", :pattern, optional_patterns,
+        optional: true)
+    end
+
+    # call solver to satisfy dependency or log error
+    def solve_dependencies
+      res = Yast::Pkg.PkgSolve(unused = true)
+      logger.info "solver run #{res.inspect}"
+
+      return if res
+
+      logger.error "Solver failed: #{Yast::Pkg.LastError}"
+      logger.error "Details: #{Yast::Pkg.LastErrorDetails}"
+      logger.error "Solving issues: #{Yast::Pkg.PkgSolveErrors}"
+    end
+
+    # @return [Logger]
+    attr_reader :logger
+
+    def count_packages
+      Yast::Pkg.PkgMediaCount.reduce(0) { |sum, res| sum + res.reduce(0, :+) }
+    end
+
+    def import_gpg_keys
+      gpg_keys = Dir.glob(GPG_KEYS_GLOB).map(&:to_s)
+      logger.info "Importing GPG keys: #{gpg_keys}"
+      gpg_keys.each do |path|
+        Yast::Pkg.ImportGPGKey(path, true)
+      end
+    end
+
+    def add_base_repo
+      @config.data["software"]["installation_repositories"].each do |repo|
+        Yast::Pkg.SourceCreate(repo, "/") # TODO: having that dir also in config?
+      end
+
+      Yast::Pkg.SourceSaveAll
+    end
+
+    def select_base_product(name)
+      base_product = Y2Packager::Product.available_base_products.find do |product|
+        product.name == name
+      end
+      logger.info "Base product to select: #{base_product&.name}"
+      base_product&.select
+    end
+
+    REPOS_BACKUP = "/etc/zypp/repos.d.dinstaller.backup"
+    private_constant :REPOS_BACKUP
+
+    REPOS_DIR = "/etc/zypp/repos.d"
+    private_constant :REPOS_DIR
+
+    # ensure that repos backup is there and repos.d is empty
+    def store_original_repos
+      # Backup was already created, so just remove all repos
+      if File.directory?(REPOS_BACKUP)
+        logger.info "removing #{REPOS_DIR}"
+        FileUtils.rm_rf(REPOS_DIR)
+      else # move repos to backup
+        logger.info "moving #{REPOS_DIR} to #{REPOS_BACKUP}"
+        FileUtils.mv(REPOS_DIR, REPOS_BACKUP)
+      end
+    end
+
+    def restore_original_repos
+      logger.info "removing #{REPOS_DIR}"
+      FileUtils.rm_rf(REPOS_DIR)
+      logger.info "moving #{REPOS_BACKUP} to #{REPOS_DIR}"
+      FileUtils.mv(REPOS_BACKUP, REPOS_DIR)
+    end
+  end
+end

data/lib/dinstaller/storage/actions.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2022] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require "y2storage/storage_manager"
+
+module DInstaller
+  module Storage
+    # Backend class to get the list of actions over the storage devices
+    class Actions
+      # @param logger [Logger]
+      def initialize(logger)
+        @logger = logger
+      end
+
+      # All actions properly sorted
+      #
+      # @return [Array<Y2Storage::CompoundAction>]
+      def all
+        main_actions + subvolume_actions
+      end
+
+    private
+
+      # @param [Logger]
+      attr_reader :logger
+
+      # Sorted main actions (everything except subvolume actions)
+      #
+      # @return [Array<Y2Storage::CompoundAction>]
+      def main_actions
+        actions = self.actions.reject { |a| subvol_action?(a) }
+        sort_actions(actions)
+      end
+
+      # Sorted subvolume actions
+      #
+      # @return [Array<Y2Storage::CompoundAction>]
+      def subvolume_actions
+        actions = self.actions.select { |a| subvol_action?(a) }
+        sort_actions(actions)
+      end
+
+      # All actions, without sorting
+      #
+      # @return [Array<Y2Storage::CompoundAction>]
+      def actions
+        actiongraph = Y2Storage::StorageManager.instance.staging.actiongraph
+
+        return [] unless actiongraph
+
+        actiongraph.compound_actions
+      end
+
+      # Sorts actions, placing destructive actions at the end
+      #
+      # @param actions [Array<Y2Storage::CompoundAction>]
+      # @return [Array<Y2Storage::CompoundAction>]
+      def sort_actions(actions)
+        delete, other = actions.partition(&:delete?)
+        delete.concat(other)
+      end
+
+      # Whether the action acts over a Btrfs subvolume
+      #
+      # @param action [Y2Storage::CompoundAction]
+      # @return [Boolean]
+      def subvol_action?(action)
+        action.device_is?(:btrfs_subvolume)
+      end
+    end
+  end
+end