2673

pending completion

Build # 2673

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/yast/yast-yast2/commit/<a class=hub.com/yast/yast-yast2/commit/1dab9065f7aa034e80867ecb99926f03210ff4a7">1dab9065f<a href="https://github.com/yast/yast-yast2/commit/1dab9065f7aa034e80867ecb99926f03210ff4a7">">Merge </a><a class="double-link" href="https://github.com/yast/yast-yast2/commit/<a class="double-link" href="https://github.com/yast/yast-yast2/commit/6f31d7831b2b20beb16a79d8d78ba793ef909e99">6f31d7831</a>">6f31d7831</a><a href="https://github.com/yast/yast-yast2/commit/1dab9065f7aa034e80867ecb99926f03210ff4a7"> into e52316028">e52316028</a>

Run Details

6 of 6 new or added lines in 2 files covered. (100.0%)

9779 of 33651 relevant lines covered (29.06%)

2.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.26

/library/packages/src/lib/y2packager/product_reader.rb

# ------------------------------------------------------------------------------
# Copyright (c) 2017 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.
# ------------------------------------------------------------------------------

require "yast"
require "y2packager/product"
require "y2packager/product_sorter"

Yast.import "Pkg"

module Y2Packager
  # Read the product information from libzypp
  class ProductReader
    include Yast::Logger

    class << self
      # Installation packages map
      #
      # This map contains the correspondence between products and the
      # installation package for each product.
      #
      # The information is always read again. Reason is that that url can be invalid,
      # but user fix it later. This way it cache invalid result. See bsc#1086840
      # ProductReader instance cache it properly, but caching for installation life-time
      # should be prevented.
      #
      # @return [Hash<String,String>] product name -> installation package name
      def installation_package_mapping
        installation_packages = Yast::Pkg.PkgQueryProvides("system-installation()")
        log.info "Installation packages: #{installation_packages.inspect}"

        installation_package_mapping = {}
        installation_packages.each do |list|
          pkg_name = list.first
          # There can be more instances of same package in different version. We except that one
          # package provide same product installation. So we just pick the first one.
          dependencies = Yast::Pkg.ResolvableDependencies(pkg_name, :package, "").first["deps"]
          install_provides = dependencies.find_all do |d|
            d["provides"] && d["provides"].match(/system-installation\(\)/)
          end

          # parse product name from provides. Format of provide is
          # `system-installation() = <product_name>`
          install_provides.each do |install_provide|
            product_name = install_provide["provides"][/system-installation\(\)\s*=\s*(\S+)/, 1]
            log.info "package #{pkg_name} install product #{product_name}"
            installation_package_mapping[product_name] = pkg_name
          end

        end

        installation_package_mapping
      end
    end

    # Available products
    #
    # @return [Array<Product>] Available products
    def all_products
      @all_products ||= available_products.map do |prod|
        prod_pkg = product_package(prod["product_package"], prod["source"])

        if prod_pkg
          prod_pkg["deps"].find { |dep| dep["provides"] =~ /\Adisplayorder\(\s*([0-9]+)\s*\)\z/ }
          displayorder = Regexp.last_match[1].to_i if Regexp.last_match
        end

        Y2Packager::Product.new(
          name: prod["name"], short_name: prod["short_name"], display_name: prod["display_name"],
          version: prod["version"], arch: prod["arch"], category: prod["category"],
          vendor: prod["vendor"], order: displayorder,
          installation_package: installation_package_mapping[prod["name"]]
        )
      end
    end

    # In installation Read the available libzypp base products for installation
    # @return [Array<Y2Packager::Product>] the found available base products,
    #   the products are sorted by the 'displayorder' provides value
    def available_base_products
      # If no product contains a 'system-installation()' tag but there is only 1 product,
      # we assume that it is the base one.
      if all_products.size == 1 && installation_package_mapping.empty?
        log.info "Assuming that #{all_products.inspect} is the base product."
        return all_products
      end

      # only installable products
      products = all_products.select(&:installation_package).sort(&::Y2Packager::PRODUCT_SORTER)
      log.info "available base products #{products}"
      products
    end

    # Read the installed base product
    # @return [Y2Packager::Product,nil] the installed base product or nil if not found
    def installed_base_product
      base = base_product
      return nil unless base

      Y2Packager::Product.from_h(base)
    end

    # All installed products
    # @return [Array<Y2Packager::Product>] the product list
    def all_installed_products
      installed_products.map { |p| Y2Packager::Product.from_h(p) }
    end

    def product_package(name, repo_id)
      return nil unless name
      Yast::Pkg.ResolvableDependencies(name, :package, "").find do |prod|
        prod["source"] == repo_id
      end
    end

  private

    # read the available products, remove potential duplicates
    # @return [Array<Hash>] pkg-bindings data structure
    def zypp_products
      products = Yast::Pkg.ResolvableProperties("", :product, "")

      # remove duplicates, there migth be different flavors ("DVD"/"POOL")
      # or archs (x86_64/i586), when selecting the product to install later
      # libzypp will select the correct arch automatically
      products.uniq! { |p| "#{p["name"]}__#{p["version"]}" }
      log.info "Found products: #{products.map { |p| p["name"] }}"

      products
    end

    # read the available products, remove potential duplicates
    # @return [Array<Hash>] pkg-bindings data structures
    def available_products
      # select only the available or to be installed products
      zypp_products.select { |p| p["status"] == :available || p["status"] == :selected }
    end

    # read the installed products
    # @return [Array<Hash>] pkg-bindings data structures
    def installed_products
      # select only the installed or to be removed products
      zypp_products.select { |p| p["status"] == :installed || p["status"] == :removed }
    end

    # find the installed base product
    # @return[Hash,nil] the pkg-bindings product structure or nil if not found
    def base_product
      # The base product is identified by the /etc/products.d/baseproduct symlink
      # and because a symlink can point only to one file there can be only one base product.
      # The "installed" conditition is actually not required because that symlink is created
      # only for installed products. (Just make sure it still works in case the libzypp
      # internal implementation is changed.)
      base = installed_products.find { |p| p["type"] == "base" }

      log.info("Found installed base product: #{base}")
      base
    end

    def installation_package_mapping
      @installation_package_mapping ||= self.class.installation_package_mapping
    end
  end
end

1	# ------------------------------------------------------------------------------
2	# Copyright (c) 2017 SUSE LLC, All Rights Reserved.
3	#
4	# This program is free software; you can redistribute it and/or modify it under
5	# the terms of version 2 of the GNU General Public License as published by the
6	# Free Software Foundation.
7	#
8	# This program is distributed in the hope that it will be useful, but WITHOUT
9	# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
10	# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
11	# ------------------------------------------------------------------------------
12
13	require "yast"	1✔
14	require "y2packager/product"	1✔
15	require "y2packager/product_sorter"	1✔
16
17	Yast.import "Pkg"	1✔
18
19	module Y2Packager	1✔
20	# Read the product information from libzypp
21	class ProductReader	1✔
22	include Yast::Logger	1✔
23
24	class << self	1✔
25	# Installation packages map
26	#
27	# This map contains the correspondence between products and the
28	# installation package for each product.
29	#
30	# The information is always read again. Reason is that that url can be invalid,
31	# but user fix it later. This way it cache invalid result. See bsc#1086840
32	# ProductReader instance cache it properly, but caching for installation life-time
33	# should be prevented.
34	#
35	# @return [Hash<String,String>] product name -> installation package name
36	def installation_package_mapping	1✔
37	installation_packages = Yast::Pkg.PkgQueryProvides("system-installation()")	29✔
38	log.info "Installation packages: #{installation_packages.inspect}"	29✔
39
40	installation_package_mapping = {}	29✔
41	installation_packages.each do \|list\|	29✔
42	pkg_name = list.first	×
43	# There can be more instances of same package in different version. We except that one
44	# package provide same product installation. So we just pick the first one.
45	dependencies = Yast::Pkg.ResolvableDependencies(pkg_name, :package, "").first["deps"]	×
46	install_provides = dependencies.find_all do \|d\|	×
47	d["provides"] && d["provides"].match(/system-installation\(\)/)	×
48	end
49
50	# parse product name from provides. Format of provide is
51	# `system-installation() = <product_name>`
52	install_provides.each do \|install_provide\|	×
53	product_name = install_provide["provides"][/system-installation\(\)\s=\s(\S+)/, 1]	×
54	log.info "package #{pkg_name} install product #{product_name}"	×
55	installation_package_mapping[product_name] = pkg_name	×
56	end
57
58	end
59
60	installation_package_mapping	29✔
61	end
62	end
63
64	# Available products
65	#
66	# @return [Array<Product>] Available products
67	def all_products	1✔
68	@all_products \|\|= available_products.map do \|prod\|	14✔
69	prod_pkg = product_package(prod["product_package"], prod["source"])	7✔
70
71	if prod_pkg	7✔
72	prod_pkg["deps"].find { \|dep\| dep["provides"] =~ /\Adisplayorder\(\s([0-9]+)\s\)\z/ }	×
73	displayorder = Regexp.last_match[1].to_i if Regexp.last_match	×
74	end
75
76	Y2Packager::Product.new(	7✔
77	name: prod["name"], short_name: prod["short_name"], display_name: prod["display_name"],
78	version: prod["version"], arch: prod["arch"], category: prod["category"],
79	vendor: prod["vendor"], order: displayorder,
80	installation_package: installation_package_mapping[prod["name"]]
81	)
82	end
83	end
84
85	# In installation Read the available libzypp base products for installation
86	# @return [Array<Y2Packager::Product>] the found available base products,
87	# the products are sorted by the 'displayorder' provides value
88	def available_base_products	1✔
89	# If no product contains a 'system-installation()' tag but there is only 1 product,
90	# we assume that it is the base one.
91	if all_products.size == 1 && installation_package_mapping.empty?	6✔
92	log.info "Assuming that #{all_products.inspect} is the base product."	1✔
93	return all_products	1✔
94	end
95
96	# only installable products
97	products = all_products.select(&:installation_package).sort(&::Y2Packager::PRODUCT_SORTER)	5✔
98	log.info "available base products #{products}"	5✔
99	products	5✔
100	end
101
102	# Read the installed base product
103	# @return [Y2Packager::Product,nil] the installed base product or nil if not found
104	def installed_base_product	1✔
105	base = base_product	1✔
106	return nil unless base	1✔
107
108	Y2Packager::Product.from_h(base)	1✔
109	end
110
111	# All installed products
112	# @return [Array<Y2Packager::Product>] the product list
113	def all_installed_products	1✔
114	installed_products.map { \|p\| Y2Packager::Product.from_h(p) }	2✔
115	end
116
117	def product_package(name, repo_id)	1✔
118	return nil unless name	7✔
119	Yast::Pkg.ResolvableDependencies(name, :package, "").find do \|prod\|	4✔
120	prod["source"] == repo_id	×
121	end
122	end
123
124	private	1✔
125
126	# read the available products, remove potential duplicates
127	# @return [Array<Hash>] pkg-bindings data structure
128	def zypp_products	1✔
129	products = Yast::Pkg.ResolvableProperties("", :product, "")	10✔
130
131	# remove duplicates, there migth be different flavors ("DVD"/"POOL")
132	# or archs (x86_64/i586), when selecting the product to install later
133	# libzypp will select the correct arch automatically
134	products.uniq! { \|p\| "#{p["name"]}__#{p["version"]}" }	17✔
135	log.info "Found products: #{products.map { \|p\| p["name"] }}"	19✔
136
137	products	10✔
138	end
139
140	# read the available products, remove potential duplicates
141	# @return [Array<Hash>] pkg-bindings data structures
142	def available_products	1✔
143	# select only the available or to be installed products
144	zypp_products.select { \|p\| p["status"] == :available \|\| p["status"] == :selected }	14✔
145	end
146
147	# read the installed products
148	# @return [Array<Hash>] pkg-bindings data structures
149	def installed_products	1✔
150	# select only the installed or to be removed products
151	zypp_products.select { \|p\| p["status"] == :installed \|\| p["status"] == :removed }	5✔
152	end
153
154	# find the installed base product
155	# @return[Hash,nil] the pkg-bindings product structure or nil if not found
156	def base_product	1✔
157	# The base product is identified by the /etc/products.d/baseproduct symlink
158	# and because a symlink can point only to one file there can be only one base product.
159	# The "installed" conditition is actually not required because that symlink is created
160	# only for installed products. (Just make sure it still works in case the libzypp
161	# internal implementation is changed.)
162	base = installed_products.find { \|p\| p["type"] == "base" }	2✔
163
164	log.info("Found installed base product: #{base}")	1✔
165	base	1✔
166	end
167
168	def installation_package_mapping	1✔
169	@installation_package_mapping \|\|= self.class.installation_package_mapping	1✔
170	end
171	end
172	end

yast / yast-yast2 / 2673

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous