cfa_grub2 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44d755734cf3e0bb54735aafb2eebe4ba46437eb
+  data.tar.gz: 875e4f91ca2d0b12f755fc2186ae7c4e007f9099
+SHA512:
+  metadata.gz: 3f9ddf0fe7a58edaa0a5f60a6a39a2bbadeed15f260a131d3f4d77754503cbf21248c2c96f3084fc20ac8e4126e5413f34a5d3ada6e6b6e72ca22a0fd293b367
+  data.tar.gz: 5e6bd382abf70b158c6b0b2ddcddd0f1d88273669cf7dbb7f0eb8aa4ef428197cfff816d76ac1d4dcc6ddb75f8f0a0dd70793fcc0f96efd202709c1890b659a7

data/lib/cfa/grub2/default.rb

@@ -0,0 +1,230 @@
+require "cfa/base_model"
+require "cfa/augeas_parser"
+require "cfa/placer"
+require "cfa/matcher"
+
+module CFA
+  module Grub2
+    # Represents grub configuration in /etc/default/grub
+    # Main features:
+    #
+    # - Do not overwrite files
+    # - When setting value first try to just change value if key already exists
+    # - When key is not set, then try to find commented out line with key and
+    #   replace it with real config
+    # - When even commented out code is not there, then append configuration
+    #   to the end of file
+    class Default < BaseModel
+      attributes(
+        timeout:     "GRUB_TIMEOUT",
+        distributor: "GRUB_DISTRIBUTOR",
+        gfxmode:     "GRUB_GFXMODE",
+        theme:       "GRUB_THEME"
+      )
+
+      PARSER = AugeasParser.new("sysconfig.lns")
+      PATH = "/etc/default/grub"
+
+      def initialize(file_handler: File)
+        super(PARSER, PATH, file_handler: file_handler)
+      end
+
+      def save(changes_only: false)
+        # serialize kernel params object before save
+        kernels = [@kernel_params, @xen_hypervisor_params, @xen_kernel_params,
+                   @recovery_params]
+        kernels.each do |params|
+          # FIXME: this empty prevent writing explicit empty kernel params.
+          generic_set(params.key, params.serialize) if params && !params.empty?
+        end
+
+        super
+      end
+
+      def load
+        super
+
+        kernels = [kernel_params, xen_hypervisor_params, xen_kernel_params,
+                   recovery_params]
+        kernels.each do |kernel|
+          param_line = data[kernel.key]
+          kernel.replace(param_line) if param_line
+        end
+      end
+
+      def os_prober
+        @os_prober ||= BooleanValue.new(
+          "GRUB_DISABLE_OS_PROBER", self,
+          # grub key is disable, so use reverse logic
+          true_value: "false", false_value: "true"
+        )
+      end
+
+      def kernel_params
+        @kernel_params ||= KernelParams.new(
+          data["GRUB_CMDLINE_LINUX_DEFAULT"], "GRUB_CMDLINE_LINUX_DEFAULT"
+        )
+      end
+
+      def xen_hypervisor_params
+        @xen_hypervisor_params ||= KernelParams.new(
+          data["GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT"],
+          "GRUB_CMDLINE_LINUX_XEN_REPLACE_DEFAULT"
+        )
+      end
+
+      def xen_kernel_params
+        @xen_kernel_params ||= KernelParams.new(
+          data["GRUB_CMDLINE_LINUX_XEN"], "GRUB_CMDLINE_LINUX_XEN"
+        )
+      end
+
+      def recovery_params
+        @recovery_params ||= KernelParams.new(
+          data["GRUB_CMDLINE_LINUX_RECOVERY"], "GRUB_CMDLINE_LINUX_RECOVERY"
+        )
+      end
+
+      def recovery_entry
+        @recovery ||= BooleanValue.new(
+          "GRUB_DISABLE_RECOVERY", self,
+          # grub key is disable, so use reverse logic
+          true_value: "false", false_value: "true"
+        )
+      end
+
+      def cryptodisk
+        @cryptodisk ||= BooleanValue.new("GRUB_ENABLE_CRYPTODISK", self)
+      end
+
+      def terminal
+        case data["GRUB_TERMINAL"]
+        when "", nil   then nil
+        when "console" then :console
+        when "serial"  then :serial
+        when "gfxterm" then :gfxterm
+        else
+          raise "unknown GRUB_TERMINAL option #{data["GRUB_TERMINAL"].inspect}"
+        end
+      end
+
+      VALID_TERMINAL_OPTIONS = [:serial, :console, :gfxterm]
+      def terminal=(value)
+        if !VALID_TERMINAL_OPTIONS.include?(value)
+          raise ArgumentError, "invalid value #{value.inspect}"
+        end
+
+        generic_set("GRUB_TERMINAL", value.to_s)
+      end
+
+      def serial_console=(value)
+        self.terminal = :serial
+        generic_set("GRUB_SERIAL_COMMAND", value)
+      end
+
+      def serial_console
+        data["GRUB_SERIAL_COMMAND"]
+      end
+
+      # Represents kernel append line with helpers to easier modification.
+      # TODO: handle quoting, maybe have own lense to parse/serialize kernel
+      #       params?
+      class KernelParams
+        attr_reader :key
+
+        def initialize(line, key)
+          @tree = ParamTree.new(line)
+          @key = key
+        end
+
+        def serialize
+          @tree.to_string
+        end
+
+        # replaces kernel params with passed line
+        def replace(line)
+          @tree = ParamTree.new(line)
+        end
+
+        # checks if there is any parameter
+        def empty?
+          serialize.empty?
+        end
+
+        # gets value for parameters.
+        # @return possible values are `false` when parameter missing,
+        #   `true` when parameter without value placed, string if single
+        #   instance with value is there and array if multiple instance with
+        #   values are there.
+        #
+        # @example different values
+        #   line = "quite console=S0 console=S1 vga=0x400"
+        #   params = KernelParams.new(line)
+        #   params.parameter("quite") # => true
+        #   params.parameter("verbose") # => false
+        #   params.parameter("vga") # => "0x400"
+        #   params.parameter("console") # => ["S0", "S1"]
+        #
+        def parameter(key)
+          values = @tree.data
+            .select { |e| e[:key] == key }
+            .map { |e| e[:value] }
+
+          return false if values.empty?
+          return values if values.size > 1
+          return true if values.first == true
+
+          values.first
+        end
+
+        # Adds new parameter to kernel command line. Uses augeas placers.
+        # To replace value use {ReplacePlacer}
+        def add_parameter(key, value, placer = AppendPlacer.new)
+          element = placer.new_element(@tree)
+
+          element[:key]   = key
+          element[:value] = value
+        end
+
+        # Removes parameter from kernel command line.
+        # @param matcher [Matcher] to find entry to remove
+        def remove_parameter(matcher)
+          @tree.data.reject!(&matcher)
+        end
+
+        # Represents parsed kernel parameters tree. Parses in initialization
+        # and backserilized by `to_string`.
+        # TODO: replace it via augeas parser when someone write lense
+        class ParamTree
+          attr_reader :data
+
+          def initialize(line)
+            line ||= ""
+            pairs = line.split(/\s/)
+              .reject(&:empty?)
+              .map { |e| e.split("=", 2) }
+
+            @data = pairs.map do |k, v|
+              {
+                key:   k,
+                value: v || true, # kernel param without value have true
+              }
+            end
+          end
+
+          def to_string
+            snippets = @data.map do |e|
+              if e[:value] == true
+                e[:key]
+              else
+                "#{e[:key]}=#{e[:value]}"
+              end
+            end
+
+            snippets.join(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cfa/grub2/device_map.rb

@@ -0,0 +1,67 @@
+require "cfa/base_model"
+require "cfa/augeas_parser"
+require "cfa/placer"
+require "cfa/matcher"
+
+module CFA
+  module Grub2
+    # Represents grub device map in /etc/grub2/device_map
+    # for details see https://www.gnu.org/software/grub/manual/html_node/Device-map.html
+    # Main features:
+    #
+    # - Do not overwrite files
+    # - When setting value first try to just change value if key already exists
+    # - When grub key is not there, then add to file
+    # - checks and raise exception if number of mappings exceed limit 8.
+    #   Limitation is caused by BIOS Int 13 used by grub2 for selecting boot
+    #   device.
+    class DeviceMap < BaseModel
+      PARSER = AugeasParser.new("device_map.lns")
+      PATH = "/etc/grub2/device.map"
+
+      def initialize(file_handler: File)
+        super(PARSER, PATH, file_handler: file_handler)
+      end
+
+      def save(changes_only: false)
+        raise "Too much grub devices. Limit is 8." if grub_devices.size > 8
+
+        super
+      end
+
+      # @return [String] grub device name for given system device
+      def grub_device_for(system_dev)
+        matcher = Matcher.new(value_matcher: system_dev)
+        entry = data.select(matcher)
+
+        entry.empty? ? nil : entry.first[:key]
+      end
+
+      # @return [String] system device name for given grub device
+      def system_device_for(grub_device)
+        data[grub_device]
+      end
+
+      # Appends to configuration mapping between grub_device and system_device
+      # @note if mapping for given grub device is already defined, it will be
+      #   overwritten
+      def add_mapping(grub_device, system_device)
+        generic_set(grub_device, system_device)
+      end
+
+      # Removes mapping for given grub device
+      def remove_mapping(grub_device)
+        data.delete(grub_device)
+      end
+
+      # @return [Array<String>] list of all grub devices which have mapping.
+      #   If there is no mapping, then it return empty list.
+      def grub_devices
+        matcher = Matcher.new { |k, _v| k !~ /comment/ }
+        entries = data.select(matcher)
+
+        entries.map { |e| e[:key] }
+      end
+    end
+  end
+end

data/lib/cfa/grub2/grub_cfg.rb

@@ -0,0 +1,39 @@
+require "cfa/base_model"
+
+module CFA
+  module Grub2
+    # Represents generated grub configuration at /boot/grub2/grub.cfg
+    # Main features:
+    #
+    # - List of generated sections including translations
+    class GrubCfg < BaseModel
+      PATH = "/boot/grub2/grub.cfg"
+
+      # @private only internal parser
+      class Parser
+        def self.parse(string)
+          menu_lines = string.lines.grep(/menuentry\s*'/)
+          menu_lines.map { |line| line[/\s*menuentry\s*'([^']+)'.*/, 1] }
+        end
+
+        def self.serialize(_string)
+          raise NotImplementedError,
+            "Serializing not implemented, use grub2 generator"
+        end
+
+        def self.empty
+          []
+        end
+      end
+
+      def initialize(file_handler: File)
+        super(Parser, PATH, file_handler: file_handler)
+      end
+
+      # @return [Array<String>] sections from grub.cfg in order as they appear
+      def sections
+        data
+      end
+    end
+  end
+end

data/lib/cfa/grub2/install_device.rb

@@ -0,0 +1,94 @@
+require "cfa/base_model"
+
+module CFA
+  module Grub2
+    # specific parser for install devices.
+    # File format is easy element per line without comments.
+    # for better readability special values generic_mbr and activate is at
+    # the end of file
+    module InstallDeviceParser
+      # returns list of non-empty lines
+      def self.parse(string)
+        string.lines.map(&:strip).delete_if(&:empty?)
+      end
+
+      # gets list of devices and create file content from it
+      def self.serialize(data)
+        activate = data.delete("activate")
+        generic_mbr = data.delete("generic_mbr")
+
+        res = data.join("\n")
+        res << "\n" unless res.empty?
+
+        res << "activate\n" if activate
+        res << "generic_mbr\n" if generic_mbr
+
+        res
+      end
+
+      def self.empty
+        []
+      end
+    end
+
+    # Model representing configuration in file /etc/default/grub_installdevice
+    class InstallDevice < BaseModel
+      PATH = "/etc/default/grub_installdevice"
+
+      def initialize(file_handler: File)
+        super(InstallDeviceParser, PATH, file_handler: file_handler)
+      end
+
+      # Adds new install device. Does nothing if it is already there.
+      def add_device(dev)
+        data << dev unless data.include?(dev)
+      end
+
+      # Removes install device. Does nothing if already not there.
+      def remove_device(dev)
+        data.delete(dev)
+      end
+
+      # @return [Array<String>] non-special devices from configuration
+      def devices
+        res = data.dup
+        res.delete("generic_mbr")
+        res.delete("activate")
+
+        res
+      end
+
+      # ask if special entry for generic_mbr is there
+      def generic_mbr?
+        data.include?("generic_mbr")
+      end
+
+      # sets special entry generic_mbr
+      def generic_mbr=(enabled)
+        if enabled
+          return if generic_mbr?
+
+          data << "generic_mbr"
+        else
+          data.delete("generic_mbr")
+        end
+      end
+
+      # Ask if special entry for activate is there
+      def activate?
+        data.include?("activate")
+      end
+
+      # sets special entry activate
+      def activate=(enabled)
+        if enabled
+          return if activate?
+
+          data << "activate"
+        else
+          data.delete("activate")
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: cfa_grub2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josef Reidinger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cfa ~> 0.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Models allowing easy read and modification of GRUB2 configuration files.
+  It is a plugin for cfa framework.
+email:
+- jreidinger@suse.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cfa/grub2/default.rb
+- lib/cfa/grub2/device_map.rb
+- lib/cfa/grub2/grub_cfg.rb
+- lib/cfa/grub2/install_device.rb
+homepage: http://github.com/config-files-api/config_files_api_grub2
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Models for GRUB2 configuration files.
+test_files: []
+has_rdoc: