d-installer 0.4.2

data/lib/dinstaller/manager.rb

@@ -0,0 +1,261 @@
+# 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 "bootloader/proposal_client"
+require "bootloader/finish_client"
+require "dinstaller/config"
+require "dinstaller/network"
+require "dinstaller/security"
+require "dinstaller/storage"
+require "dinstaller/questions_manager"
+require "dinstaller/with_progress"
+require "dinstaller/installation_phase"
+require "dinstaller/service_status_recorder"
+require "dinstaller/dbus/clients/language"
+require "dinstaller/dbus/clients/software"
+require "dinstaller/dbus/clients/users"
+
+Yast.import "Stage"
+
+module DInstaller
+  # This class represents the top level installer manager.
+  #
+  # It is responsible for orchestrating the installation process. For module
+  # specific stuff it delegates it to the corresponding module class (e.g.,
+  # {DInstaller::Network}, {DInstaller::Storage::Proposal}, etc.) or asks
+  # other services via D-Bus (e.g., `org.opensuse.DInstaller.Software`).
+  class Manager
+    include WithProgress
+
+    # @return [Logger]
+    attr_reader :logger
+
+    # @return [QuestionsManager]
+    attr_reader :questions_manager
+
+    # @return [InstallationPhase]
+    attr_reader :installation_phase
+
+    # Constructor
+    #
+    # @param logger [Logger]
+    def initialize(config, logger)
+      @config = config
+      @logger = logger
+      @questions_manager = QuestionsManager.new(logger)
+      @installation_phase = InstallationPhase.new
+      @service_status_recorder = ServiceStatusRecorder.new
+    end
+
+    # Runs the startup phase
+    def startup_phase
+      installation_phase.startup
+
+      probe_single_product unless config.multi_product?
+
+      logger.info("Startup phase done")
+    end
+
+    # Runs the config phase
+    def config_phase
+      installation_phase.config
+
+      storage.probe(questions_manager)
+      security.probe
+      network.probe
+
+      logger.info("Config phase done")
+    rescue StandardError => e
+      logger.error "Startup error: #{e.inspect}. Backtrace: #{e.backtrace}"
+      # TODO: report errors
+    end
+
+    # Runs the install phase
+    # rubocop:disable Metrics/AbcSize
+    def install_phase
+      installation_phase.install
+
+      start_progress(9)
+
+      progress.step("Reading software repositories") do
+        software.probe
+        Yast::Installation.destdir = "/mnt"
+      end
+
+      progress.step("Partitioning") do
+        # lets propose it here to be sure that software proposal reflects product selection
+        # FIXME: maybe repropose after product selection change?
+        # first make bootloader proposal to be sure that required packages are installed
+        proposal = ::Bootloader::ProposalClient.new.make_proposal({})
+        logger.info "Bootloader proposal #{proposal.inspect}"
+        storage.install
+        # propose software after /mnt is already separated, so it uses proper
+        # target
+        software.propose
+
+        # call inst bootloader to get properly initialized bootloader
+        # sysconfig before package installation
+        Yast::WFM.CallFunction("inst_bootloader", [])
+      end
+
+      progress.step("Installing Software") { software.install }
+
+      on_target do
+        progress.step("Writing Users") { users.write }
+
+        progress.step("Writing Network Configuration") { network.install }
+
+        progress.step("Installing Bootloader") do
+          security.write
+          ::Bootloader::FinishClient.new.write
+        end
+
+        progress.step("Saving Language Settings") { language.finish }
+
+        progress.step("Writing repositories information") { software.finish }
+
+        progress.step("Finishing installation") { finish_installation }
+      end
+
+      logger.info("Install phase done")
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # Software client
+    #
+    # @return [DBus::Clients::Software]
+    def software
+      @software ||= DBus::Clients::Software.new.tap do |client|
+        client.on_service_status_change do |status|
+          service_status_recorder.save(client.service.name, status)
+        end
+      end
+    end
+
+    # Language manager
+    #
+    # @return [DBus::Clients::Language]
+    def language
+      @language ||= DBus::Clients::Language.new
+    end
+
+    # Users client
+    #
+    # @return [DBus::Clients::Users]
+    def users
+      @users ||= DBus::Clients::Users.new.tap do |client|
+        client.on_service_status_change do |status|
+          service_status_recorder.save(client.service.name, status)
+        end
+      end
+    end
+
+    # Network manager
+    #
+    # @return [Network]
+    def network
+      @network ||= Network.new(logger)
+    end
+
+    # Storage manager
+    #
+    # @return [Storage::Manager]
+    def storage
+      @storage ||= Storage::Manager.new(logger, config)
+    end
+
+    # Security manager
+    #
+    # @return [Security]
+    def security
+      @security ||= Security.new(logger, config)
+    end
+
+    # Actions to perform when a product is selected
+    #
+    # @note The config phase is executed.
+    def select_product(product)
+      config.pick_product(product)
+      config_phase
+    end
+
+    # Name of busy services
+    #
+    # @see ServiceStatusRecorder
+    #
+    # @return [Array<String>]
+    def busy_services
+      service_status_recorder.busy_services
+    end
+
+    # Registers a callback to be called when the status of a service changes
+    #
+    # @see ServiceStatusRecorder
+    def on_services_status_change(&block)
+      service_status_recorder.on_service_status_change(&block)
+    end
+
+  private
+
+    attr_reader :config
+
+    # @return [ServiceStatusRecorder]
+    attr_reader :service_status_recorder
+
+    # Performs required steps after installing the system
+    #
+    # For now, this only unmounts the installed system and copies installation logs. Note that YaST
+    # performs many more steps like copying configuration files, creating snapshots, etc. Adding
+    # more features to D-Installer could require to recover some of that YaST logic.
+    def finish_installation
+      Yast::WFM.CallFunction("copy_logs_finish", ["Write"])
+      storage.finish
+    end
+
+    # Runs a block in the target system
+    def on_target(&block)
+      old_handle = Yast::WFM.SCRGetDefault
+      handle = Yast::WFM.SCROpen("chroot=#{Yast::Installation.destdir}:scr", false)
+      Yast::WFM.SCRSetDefault(handle)
+
+      begin
+        block.call
+      rescue StandardError => e
+        logger.error "Error while running on target tasks: #{e.inspect}"
+      ensure
+        Yast::WFM.SCRSetDefault(old_handle)
+        Yast::WFM.SCRClose(handle)
+      end
+    end
+
+    # Runs the config phase for the first product found
+    #
+    # Adjust the configuration and run the config phase.
+    #
+    # This method is expected to be used on single-product scenarios.
+    def probe_single_product
+      selected = config.data["products"].keys.first
+      config.pick_product(selected)
+      config_phase
+    end
+  end
+end

data/lib/dinstaller/network.rb

@@ -0,0 +1,53 @@
+# 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 "singleton"
+require "yast"
+require "y2network/proposal_settings"
+Yast.import "Lan"
+
+module DInstaller
+  # Backend class to handle network configuration
+  class Network
+    def initialize(logger)
+      @logger = logger
+    end
+
+    # Probes the network configuration
+    def probe
+      logger.info "Probing network"
+      Yast::Lan.read_config
+      settings = Y2Network::ProposalSettings.instance
+      settings.refresh_packages
+      settings.apply_defaults
+    end
+
+    # Writes the network configuration to the installed system
+    def install
+      Yast::WFM.CallFunction("save_network", [])
+    end
+
+  private
+
+    # @return [Logger]
+    attr_reader :logger
+  end
+end

data/lib/dinstaller/package_callbacks.rb

@@ -0,0 +1,69 @@
+# 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"
+
+Yast.import "Pkg"
+
+# YaST specific code lives under this namespace
+module DInstaller
+  # This class represents the installer status
+  class PackageCallbacks
+    class << self
+      def setup(pkg_count, progress)
+        new(pkg_count, progress).setup
+      end
+    end
+
+    def initialize(pkg_count, progress)
+      @total = pkg_count
+      @installed = 0
+      @progress = progress
+    end
+
+    def setup
+      Yast::Pkg.CallbackDonePackage(
+        fun_ref(method(:package_installed), "string (integer, string)")
+      )
+    end
+
+  private
+
+    # @return [DInstaller::Progress]
+    attr_reader :progress
+
+    def fun_ref(method, signature)
+      Yast::FunRef.new(method, signature)
+    end
+
+    # TODO: error handling
+    def package_installed(_error, _reason)
+      @installed += 1
+      progress.step(msg)
+
+      ""
+    end
+
+    def msg
+      "Installing packages (#{@total - @installed} remains)"
+    end
+  end
+end

data/lib/dinstaller/progress.rb

@@ -0,0 +1,149 @@
+# 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
+  # Class to manage progress
+  #
+  # It allows to configure callbacks to be called on each step and also when the progress finishes.
+  #
+  # @example
+  #
+  #   progress = Progress.new(3)                    # 3 steps
+  #   progress.on_change { puts progress.message }  # configures callbacks
+  #   progress.on_finish { puts "finished"  }       # configures callbacks
+  #
+  #   progress.step("Doing step1") { step1 }        # calls on_change callbacks and executes step1
+  #   progress.step("Doing step2") { step2 }        # calls on_change callbacks and executes step2
+  #
+  #   progress.current_step                         #=> <Step>
+  #   progress.current_step.id                      #=> 2
+  #   progress.current_step.description             #=> "Doing step2"
+  #
+  #   progress.finished?                            #=> false
+
+  #   progress.step("Doing step3") do               # calls on_change callbacks, executes the given
+  #     progress.current_step.description           # block and calls on_finish callbacks
+  #   end                                           #=> "Doing step3"
+  #
+  #   progress.finished?                            #=> true
+  #   progress.current_step                         #=> nil
+  class Progress
+    # Step of the progress
+    class Step
+      # Id of the step
+      #
+      # @return [Integer]
+      attr_reader :id
+
+      # Description of the step
+      #
+      # @return [String]
+      attr_reader :description
+
+      # Constructor
+      #
+      # @param id [Integer]
+      # @param description [String]
+      def initialize(id, description)
+        @id = id
+        @description = description
+      end
+    end
+
+    # Total number of steps
+    #
+    # @return [Integer]
+    attr_reader :total_steps
+
+    # Constructor
+    #
+    # @param toal_steps [Integer] total number of steps
+    def initialize(total_steps)
+      @total_steps = total_steps
+      @current_step = nil
+      @counter = 0
+      @finished = false
+      @on_change_callbacks = []
+      @on_finish_callbacks = []
+    end
+
+    # Current progress step, if any
+    #
+    # @return [Step, nil] nil if the progress is already finished or not stated yet.
+    def current_step
+      return nil if finished?
+
+      @current_step
+    end
+
+    # Runs a progress step
+    #
+    # It calls the `on_change` callbacks and then runs the given block, if any. It also calls
+    # `on_finish` callbacks after the last step.
+    #
+    # @param description [String] description of the step
+    # @param block [Proc]
+    #
+    # @return [Object, nil] result of the given block or nil if no block is given
+    def step(description, &block)
+      return if finished?
+
+      @counter += 1
+      @current_step = Step.new(@counter, description)
+      @on_change_callbacks.each(&:call)
+
+      result = block_given? ? block.call : nil
+
+      finish if @counter == total_steps
+
+      result
+    end
+
+    # Whether the last step was already done
+    #
+    # @return [Boolean]
+    def finished?
+      total_steps == 0 || @finished
+    end
+
+    # Finishes the progress and runs the callbacks
+    #
+    # This method can be called to force the progress to finish before of running all the steps.
+    def finish
+      @finished = true
+      @on_finish_callbacks.each(&:call)
+    end
+
+    # Adds a callback to be called when progress changes
+    #
+    # @param block [Proc]
+    def on_change(&block)
+      @on_change_callbacks << block
+    end
+
+    # Adds a callback to be called when progress finishes
+    #
+    # @param block [Proc]
+    def on_finish(&block)
+      @on_finish_callbacks << block
+    end
+  end
+end

data/lib/dinstaller/question.rb

@@ -0,0 +1,103 @@
+# 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
+  # This class represents a question
+  #
+  # Questions are used when some information needs to be asked. For example, a question could be
+  # created for asking whether to continue or not when an error is detected.
+  #
+  # Questions are managed by a questions manager, see {QuestionsManager}.
+  class Question
+    # Each question is identified by an unique id
+    #
+    # @return [Integer]
+    attr_reader :id
+
+    # Text of the question
+    #
+    # @return [String]
+    attr_reader :text
+
+    # Options the question offers
+    #
+    # The question must be answered with one of that options.
+    #
+    # @return [Array<Symbol>]
+    attr_reader :options
+
+    # Default option to use as answer
+    #
+    # @return [Symbol, nil]
+    attr_reader :default_option
+
+    # Answer of the question
+    #
+    # @return [Symbol, nil] nil if the question is not answered yet
+    attr_reader :answer
+
+    def initialize(text, options: [], default_option: nil)
+      @id = IdGenerator.next
+      @text = text
+      @options = options
+      @default_option = default_option
+    end
+
+    # Answers the question with an option
+    #
+    # @raise [ArgumentError] if the given value is not a valid answer.
+    #
+    # @param value [Symbol]
+    def answer=(value)
+      raise ArgumentError, "Invalid answer. Options: #{options}" unless valid_answer?(value)
+
+      @answer = value
+    end
+
+    # Whether the question is already answered
+    #
+    # @return [Boolean]
+    def answered?
+      !answer.nil?
+    end
+
+  private
+
+    # Checks whether the given value is a valid answer
+    #
+    # @param value [Symbol]
+    # @return [Boolean]
+    def valid_answer?(value)
+      options.include?(value)
+    end
+
+    # Helper class for generating unique ids
+    class IdGenerator
+      # Generates the next id to be used
+      #
+      # @return [Integer]
+      def self.next
+        @last_id ||= 0
+        @last_id += 1
+      end
+    end
+  end
+end