File yomi-0.0.1+git.1598948600.9a9eab0.obscpio of Package yomi-formula

Overview Repositories Revisions Requests Users Attributes Meta

File yomi-0.0.1+git.1598948600.9a9eab0.obscpio of Package yomi-formula (Revision 39b9b0b7b655558dded23160f9cea67a)

Currently displaying revision 39b9b0b7b655558dded23160f9cea67a , Show latest

07070100000000000081A40000427000000032000000015F4E04F800002C5D000000000000000000000000000000000000002A00000000yomi-0.0.1+git.1598948600.9a9eab0/LICENSE                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

"Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

(a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
07070100000001000081A40000427000000032000000015F4E04F80000A396000000000000000000000000000000000000002C00000000yomi-0.0.1+git.1598948600.9a9eab0/README.md# Yomi - Yet one more installer

# What is Yomi

Yomi (yet one more installer) is a new proposal for an installer for
the [open]SUSE family. It is designed as a
[SaltStack](https://www.saltstack.com/) state, and expected to be used
in situations were unattended installations for heterogeneous nodes is
required, and where some bits of intelligence in the configuration
file can help to customize the installation.

Being also a Salt state makes the installation process one more step
during the provisioning stage, making on Yomi a good candidate for
integration in any workflow were SaltStack is used.

# Overview

To execute Yomi we need a modern version of Salt, as we need special
features are only on the
[master](https://github.com/saltstack/salt/tree/master) branch of
Salt. Technically we can use the last released version of Salt for
salt-master, but for the minions we need the most up-to-date
version. The good news is that most of the patches are currently
merged in the openSUSE package of Salt.

Yomi is developed in
[OBS](https://build.opensuse.org/project/show/systemsmanagement:yomi),
and actually consists on two components:

* [yomi-formula](https://build.opensuse.org/package/show/systemsmanagement:yomi/yomi-formula):
  contains the Salt states and modules requires to drive an
  installation. The [source code](https://github.com/openSUSE/yomi) of
  the project in available under the openSUSE group in GitHub.
* [openSUSE-Tubleweed-Yomi](https://build.opensuse.org/package/show/systemsmanagement:yomi/openSUSE-Tumbleweed-Yomi):
  is the image that can be used too boot the new nodes, that includes
  the `salt-minion` service already configured. There are two versions
  of this image, one that is used as a LiveCD image and other designed
  to be used from a PXE Boot server.

The installation process of Yomi will require:

* Install and configure the
  [`salt-master`](#installing-and-configuring-salt-master) service.
* Install the [`yomi-formula`](#the-yomi-formula) package.
* Prepare the [pillar](#pillar-in-yomi) for the new installations.
* Boot the new systems with the [ISO image](#the-iso-image) or via
  [PXE boot](#pxe-boot)

Currently Yomi support the installation under x86_64 and ARM64
(aarch64) with EFI.

# Installing and configuring salt-master

SaltStack can be deployed with different architectures. The
recommended one will require the `salt-master` service.

```bash
zypper in salt-master

systemctl enable --now salt-master.service
```

## Other ways to install salt-master

For different ways of installation, read the [official
documentation](https://docs.saltstack.com/en/latest/topics/installation/index.html). For
example, for development purposes installing it inside a virtual
environment can be a good idea:

```bash
python3 -mvenv venv

source venv/bin/activate

pip install --upgrade pip
pip install salt

# Create the basic layout and config files
mkdir -p venv/etc/salt/pki/{master,minion} \
      venv/etc/salt/autosign_grains \
      venv/var/cache/salt/master/file_lists/roots

cat <<EOF > venv/etc/salt/master
root_dir: $(pwd)/venv

file_roots:
  base:
    - $(pwd)/srv/salt

pillar_roots:
  base:
    - $(pwd)/srv/pillar
EOF
```

## Looking for the pillar

Salt pillar are the data that the Salt states use to decide the
actions that needs to be done. For example, in the case of Yomi the
typical data will be the layout of the hard disks, the software
patterns that will be installed, or the users that will be
created. For a complete explanation of the pillar required by Yomi,
check the section [Pillar in Yomi](#pillar-in-yomi)

By default Salt will search the states in `/srv/salt`, and the pillar
in `/srv/pillar`, as established by `file_roots` and `pillar_roots`
parameters in the default configuration file (`/etc/salt/master`).

To indicate a different place where to find the pillar, we can add a
new snippet in the `/etc/salt/master.d` directory:

```bash
cat <<EOF > /etc/salt/master.d/pillar.conf
pillar_roots:
  base:
    - /srv/pillar
	- /usr/share/yomi/pillar
EOF
```

The `yomi-formula` package already contains an example of such
configuration. Check section [Looking for the pillar in
Yomi](#looking-for-the-pillar-in-yomi)

## Enabling auto-sign

To simplify the discovery and key management of the minions, we can
use the auto-sign feature of Salt. To do that we need to add a new
file in `/etc/salt/master.d`.

```bash
echo "autosign_grains_dir: /etc/salt/autosign_grains" > \
     /etc/salt/master.d/autosign.conf
```

The Yomi ISO image available in Factory already export some UUIDs
generated for each minion, so we need to list into the master all the
possible valid UUIDs.

```bash
mkdir -p /etc/salt/autosign_grains

for i in $(seq 0 9); do
  echo $(uuidgen --md5 --namespace @dns --name http://opensuse.org/$i)
done > /etc/salt/autosign_grains/uuid
```

The `yomi-formula` package already contains an example of such
configuration. Check section [Enabling auto-sing in
Yomi](#enabling-auto-sing-in-yomi)

## Salt API

The `salt-master` service can be accessed via a REST API, provided by
an external tool that needs to be enabled.

```bash
zypper in salt-api

systemctl enable --now salt-api.service
```

There are different options to configure the `salt-api` service, but
is safe to choose `CherryPy` as a back-end to serve the requests of
Salt API.

We need to configure this service to listen to one port, for example
8000, and to associate an authorization mechanism. Read the Salt
documentation about this topic for different options.

```bash
cat <<EOF > /etc/salt/master.d/salt-api.conf
rest_cherrypy:
  port: 8000
  debug: no
  disable_ssl: yes
EOF

cat <<EOF > /etc/salt/master.d/eauth.conf
external_auth:
  file:
    ^filename: /etc/salt/user-list.txt
    salt:
      - .*
      - '@wheel'
      - '@runner'
      - '@jobs'
EOF

echo "salt:linux" > /etc/salt/user-list.txt
```

The `yomi-formula` package already contains an example of such
configuration. Check section [Salt API in Yomi](#salt-api-in-yomi)

# The Yomi formula

The states and modules required by Salt to drive an installation can
be installed where the `salt-master` resides:

```bash
zypper in yomi-formula
```

This package will install the states in
`/usr/share/salt-formulas/states`, some pillar examples in
`/usr/share/yomi/pillar` and configuration files in `/usr/share/yomi`.

## Looking for the pillar in Yomi

Yomi expect from the pillar to be a normal YAML document, optionally
generated by a Jinja template, as is usual in Salt.

The schema of the pillar is described in the section [Pillar reference
for Yomi](#pillar-reference-for-yomi), but the `yomi-formula` package
provides a set of examples that can be used to deploy MicroOS
installations, Kubic, LVM, RAID or simple openSUSE Tumbleweed ones.

In order to `salt-master` can find the pillar, we need to change the
`pillar_roots` entry in the configuration file, or use the one
provided by the package:

```bash
cp -a /usr/share/yomi/pillar.conf /etc/salt/master.d/
systemctl restart salt-master.service
```

## Enabling auto-sing in Yomi

The images generated by the Open Build Service that are ready to be
used together with Yomi contains a list a random UUID, that can be
used as a auto-sing grain in `salt-master`.

We can enable this feature adding the configuration file provided by
the package:

```bash
cp /usr/share/yomi/autosign.conf /etc/salt/master.d/
systemctl restart salt-master.service
```

## Salt API in Yomi

As described in the section [Salt API](#salt-api), we need to enable
the `salt-api` service in order to provide a REST API service to
`salt-minion`.

This service is used by Yomi to monitor the installation, reading the
event bus of Salt. To enable the real-time events we need to enable
set `events` field to `yes` in the configuration section of the
pillar.

We can enable this service easily (after installing the `salt-api`
package and the dependencies) using the provided configuration file:

```bash
cp /usr/share/yomi/salt-api.conf /etc/salt/master.d/
systemctl restart salt-master.service
```

Feel free to edit `/etc/salt/master.d/salt-api.conf` and provide the
required certificates to enable the SSL connection, an use a different
authorization mechanism. The current one is based on reading the file
`/usr/share/yomi/user-list.txt`, that is storing the password in plain
text. So please, *do not* use this in production.

### Real time monitoring in Yomi

Once we check that in our `config` of the pillar contains this:

```yaml
config:
  events: yes
```

We can launch the `monitor` tool.

```bash
export SALTAPI_URL=http://localhost:8000
export SALTAPI_EAUTH=file
export SALTAPI_USER=salt
export SALTAPI_PASS=linux

monitor -r -y
```

The `monitor` tool store in a local cache the authentication tokens
generated by Salt API. This will accelerate the next connection to the
service, but sometimes can cause authentication errors (for example,
when the cache is in place but the salt-master get reinstalled). The
option `-r` makes sure that this cache is removed before
connection. Check the help option of the tool for more information.

# Booting a new machine

As described in the previous sections, Yomi is a set of Salt states
that are used to drive the installation of a new operating system. To
take full control of the system where the installation will be done,
you will need to boot from an external system that provides an already
configured `salt-minion`, and a set of CLI tools required during the
installation.

We can deploy all the requirements using different mechanisms. One,
for example, is via PXE boot. We can build a server that will deliver
the Linux `kernel` and an `initrd` will all the required
software. Another alternative is to have an already live ISO image
that you use to boot from the USB port.

There is an already available image that contains all the requirements
in
[Factory](https://build.opensuse.org/package/show/openSUSE:Factory/openSUSE-Tumbleweed-Yomi). This
is an image build from openSUSE Tumbleweed repositories that includes
a very minimal set of tools, including the openSUSE version of
`salt-minion`.

To use the last version of the image, together with the last version
of `salt-minion` that includes all the patches that are under review
in the SaltStack project, you can always use the version from the
[devel
project](https://build.opensuse.org/package/show/systemsmanagement:yomi/openSUSE-Tumbleweed-Yomi)

Note that this image is a `_multibuild` one, and generates two
different images. One is a LiveCD ISO image, ready to be booted from
USB or DVD, and the other one is a PXE Boot ready image.

## The ISO image

The ISO image is a LiveCD that can be booted from USB or from DVD, and
the last version can be always be downloaded from:

```bash
wget https://download.opensuse.org/repositories/systemsmanagement:/yomi/images/iso/openSUSE-Tumbleweed-Yomi.x86_64-livecd.iso
```

## PXE Boot

The second image available is a OEM ramdisk that can be booted from
PXE Boot.

To install the image we first need to download the file
`openSUSE-Tumbleweed-Yomi.x86_64-${VERSION}-pxeboot-Build${RELEASE}.${BUILD}.install.tar`
from the Factory, or directly from the development project.

We need to start the `sftpd` service or use `dnsmasq` to behave also
as a tftp server. There is some documentation in the [openSUSE
wiki](https://en.opensuse.org/SDB:PXE_boot_installation), and if you
are using QEMU you can also check the appendix document.

```bash
mkdir -p /srv/tftpboot/pxelinux.cfg
cp /usr/share/syslinux/pxelinux.0 /srv/tftpboot

cd /srv/tftpboot
tar -xvf $IMAGE

cat <<EOF > /srv/tftpboot/pxelinux.cfg/default
default yomi
prompt   1
timeout  30

label yomi
  kernel pxeboot.kernel
  append initrd=pxeboot.initrd.xz rd.kiwi.install.pxe rd.kiwi.install.image=tftp://${SERVER}/openSUSE-Tumbleweed-Yomi.xz rd.kiwi.ramdisk ramdisk_size=1048576
EOF
```

This image is based on Tumbleweed, that leverage by default the
predictable network interface name.  If your image is based on a
different one, be sure to add `net.ifnames=1` at the end of the
`append` section.

## Finding the master node

The `salt-minion` configuration in the Yomi image will search the
`salt-master` system under the `salt` name. Is expected that the local
DNS service will resolve the `salt` name to the correct IP address.

During boot time of the Yomi image we can change the address where is
expected to find the master node. To do that we can enter under the
GRUB menu the entry `master=my_master_address`. For example
`master=10.0.2.2` will make the minion to search the master in the
address `10.0.2.2`.

An internal systemd service in the image will detect this address and
configure the `salt-minion` accordingly.

Under the current Yomi states, this address will be copied under the
new installed system, together with the key delivered by the
`salt-master` service. This means that once the system is fully
installed with the new operating system, the new `salt-minion` will
find the master directly after the first boot.

## Setting the minion ID

In a similar way, during the boot process we can set the minion ID
that will be assigned to the `salt-minion`. Using the parameter
`minion_id`. For example, `minion_id=worker01` will set the minion ID
for this system as `worker01`.

The rules for the minion ID are a bit more complicated. Salt, by
default, set the minion ID equal to the FQDN or the IP of the node if
no ID is specified. This cannot be a good idea if the IP changes, so
the current rules are:

* The value from `minion_id` boot parameter.
* The FQDN hostname of the system, if is different from localhost.
* The MAC address of the first interface of the system.

## Container

Because the versatility of Salt, is possible to execute the modules
that belong to the `salt-minion` service Yomi without the requirement
of any `salt-master` nor `salt-minion` service running. We could
launch the installation via only the `salt-call` command in local
mode.

Because of that, es possible to deliver Yomi as a single container,
composed of the different Salt and Yomi modules and states.

We can boot a machine using any mechanism, like a recovery image, and
use `podman` to register the Yomi container. This container will be
executed as a privileged one, mapping the external devices inside the
container space.

To register the container we can do:

```bash
podman pull registry.opensuse.org/systemsmanagement/yomi/images/opensuse/yomi:latest
```

Is recommended to create a local pillar directory;

```bash
mkdir pillar
```

Once we have the pillar data, we can launch the installer:

```bash
podman run --privileged --rm \
  -v /dev:/dev \
  -v /run/udev:/run/udev \
  -v ./pillar:/srv/pillar \
  <CONTAINER_ID> \
  salt-call --local state.highstate
```

# Basic operations

Once `salt-master` is configured and running, the `yomi-formula`
states are available and a new system is booted with a up-to-date
`salt-minion`, we can start to operate with Yomi.

The usual process is simple: describe the pillar information and apply
the `yomi` state to the node or nodes. Is not relevant how the pillar
was designed (maybe using a smart template that cover all the cases or
writing a raw YAML that only covers one single installation).  In this
section we will provide some hints about how get information and can
help in this process.

## Getting hardware information

The provided pillar are only an example of what we can do with
Yomi. Eventually we need to adapt them based on the hardware that we
have.

We can discover the hardware configuration with different
mechanism. One is get the `grains` information directly from the
minion:

```bash
salt node grains.items
```

We can get more detailed information using other Salt modules, like
`partition.list`, `network.interfaces` or `udev.info`.

With Yomi we provided a simple interface to `hwinfo` that provides in
a single report some of the information that is required to make
decisions about the pillar.

```bash
# Synchronize all the modules to the minion
salt node saltutil.sync_all

# Get a short report about some devices
salt node devices.hwinfo

# Get a detailled report about some devices
salt node devices.hwinfo short=no
```

## Configuring the pillar

The package `yomi-formula` provides some pillar examples that can be
used as a reference when you are creating your own profiles.

Salt search the pillar information in the directories listed in the
`pillar_roots` configuration entry, and using the snippet from the
section [Pillar in Yomi](#pillar-in-yomi), we can make those examples
available in our system.

In the case that we want to edit those files, we can copy them in a
different directory and add it to the `pillar_roots` entry.

```bash
mkdir -p /srv/pillar-yomi
cp -a /usr/share/yomi/pillar/* /srv/pillar-yomi

cat <<EOF > /etc/salt/master.d/pillar.conf
pillar_roots:
  base:
    - /srv/pillar-yomi
    - /srv/pillar
EOF
systemctl restart salt-master.service
```

The pillar tree start with the `top.sls` file (there is another
`top.sls` file for the states, do not confuse them).

```yaml
base:
  '*':
    - installer
```

This file is used to map the node with the data that the states will
use later. For this example the file that contain the data is
`installer.sls`, but feel free to choose a different name when you are
creating your own pillar.

This `installer.sls` is used as an entry point for the rest of the
data. Inside the file there is some Jinja templates that can be edited
to define different kinds of installations. This feature is leveraged
by the
[openQA](https://github.com/os-autoinst/os-autoinst-distri-opensuse/tree/master/tests/yomi)
tests, to easily make multiple deployments.

You can edit the `{% set VAR=VAL %}` section to adjust it to your
current profile, or create one from scratch. The files
`_storage.sls.*` are included for different scenarios, and this is the
place where the disk layout is described. Feel free to include it
directly on your pillar, or use a different mechanism to decide the
layout.

## Cleaning the disks

Yomi try to be careful with the current data stored in the disks. By
default will not remove any partition, nor will make an implicit
decision about the device where the installation will run.

If we want to remove the data from the device, we can use the provided
`devices.wipe` execution module.

```bash
# List the partitions
salt node partition.list /dev/sda

# Make sure that the new modules are in the minion
salt node saltutil.sync_all

# Remove all the partitions and the filesystem information
salt node devices.wipe /dev/sda
```

To wipe all the devices defined in the pillar at once, we can apply
the `yomi.storage.wipe` state.

```bash
# Make sure that the new modules are in the minion
salt node saltutil.sync_all

# Remove all the partitions and the filesystem information
salt node state.apply yomi.storage.wipe
```

## Applying the yomi state

Finally, to install the operating system defined by the pillar into
the new node, we need to apply the high-state:

```bash
salt node state.apply yomi
```

If we have a `top.sls` file similar to this example, living in
`/srv/salt` or in any other place where `file_roots` option is
configured:

```yaml
base:
  '*':
    - yomi
```

We can apply directly the high state:

```bash
salt node state.highstate
```

# Pillar reference for Yomi

To install a new node, we need to provide some data to describe the
installation requirements, like the layout of the partitions, file
systems used, or what software to install inside the new
deployment. This data is collected in what is Salt is known as a
[pillar](https://docs.saltstack.com/en/latest/topics/tutorials/pillar.html).

To configure the `salt-master` service to find the pillar, check the
section [Looking for the pillar](#looking-for-the-pillar).

Pillar can be associated with certain nodes in our network, making of
this technique a basic one to map a description of how and what to
install into a node. This mapping is done via the `top.sls` file:

```yaml
base:
  'C7:7E:55:62:83:17':
    - installer
```

In `installer.sls` we will describe in detail the installation
parameters that will be applied to the node which minion-id match with
`C7:7E:55:62:83:17`. Note that in this example we are using the MAC
address of the first interface as a minion-id (check the section
**Enabling Autosign** for an example).

The `installer.sls` pillar consist on several sections, that we can
describe here.

## `config` section

The `config` section contains global configuration options that will
affect the installer.

* `events`: Boolean. Optional. Default: `yes`

Yomi can fire Salt events before and after the execution of the
  internal states that Yomi use to drive the installation. Using the
  Salt API, WebSockets, or any other mechanism provided by Salt, we
  can listen the event bus and use this information to monitor the
  installer. Yomi provides a basic tool, `monitor`, that shows real
  time information about the installation process.

To disable the events, set this parameter to `no`.

Note that this option will add three new states for each single Yomi
  state. One extra state is executed always before the normal state,
  and is used to signalize that a new state will be executed. If the
  state is successfully terminated, a second extra state will send an
  event to signalize that the status of the state is positive. But if
  the state fails, a third state will send the fail signal. All those
  extra states will be showed in the final report of Salt.

* `reboot`: String. Optional. Default: `yes`

Control the way that the node will reboot. There are three possible
  values:

* `yes`: Will produce a full reboot cycle. This value can be
    specified as the "yes" string, or the `True` boolean value.

* `no`: Will no reboot after the installation.

* `kexec`: Instead of rebooting, reload the new kernel installed in
    the node.

* `halt`: The machine will halt at the end of the installation.

* `shutdown`: The machine will shut down at the end of the
    installation.

* `snapper`: Boolean. Optional. Default: `no`

In Btrfs configurations (and in LVM, but still not implemented) we
  can install the snapper tool, to do automatic snapshots before and
  after updates in the system. One installed, a first snapshot will be
  done and the GRUB entry to boot from snapshots will be added.

* `locale`: String. Optional. Default: `en_US.utf8`

Sets the system locale, more specifically the LANG= and LC\_MESSAGES
  settings. The argument should be a valid locale identifier, such as
  `de_DE.UTF-8`. This controls the locale.conf configuration file.

* `locale_message`: String. Optional.

* `keymap`: String. Optional. Default: `us`

Sets the system keyboard layout. The argument should be a valid
  keyboard map, such as `de-latin1`. This controls the "KEYMAP" entry
  in the vconsole.conf configuration file.

* `timezone`: String. Optional. Default: `UTC`

Sets the system time zone. The argument should be a valid time zone
  identifier, such as "Europe/Berlin". This controls the localtime
  symlink.

* `hostname`: String. Optional.

Sets the system hostname. The argument should be a host name,
  compatible with DNS. This controls the hostname configuration file.

* `machine_id`: String. Optional.

Sets the system's machine ID. This controls the machine-id file. If
  no one is provided, the one from the current system will be re-used.

* `target`: String. Optional. Default: `multi-user.target`

Set the default target used for the boot process.

Example:

```yaml
config:
  # Do not send events, useful for debugging
  events: no
  # Do not reboot after installation
  reboot: no
  # Always install snapper if possible
  snapper: yes
  # Set language to English / US
  locale: en_US.UTF-8
  # Japanese keyboard
  keymap: jp
  # Universal Timezone
  timezone: UTC
  # Boot in graphical mode
  target: graphical.target
```

## `partitions` section

Yomi separate partitioning the devices from providing a file system,
creating volumes or building arrays of disks. The advantage of this is
that this, usually, compose better that other approaches, and makes
more easy adding more options that needs to work correctly with the
rest of the system.

* `config`: Dictionary. Optional.

Subsection that store some configuration options related with the
  partitioner.

* `label`: String. Optional. Default: `msdos`

Default label for the partitions of the devices. We use any
    `parted` partition recognized by `mklabel`, like `gpt`, `msdos` or
    `bsd`. For UEFI systems, we need to set it to `gpt`. This value
    will be used for all the devices if is not overwritten.

* `initial_gap`: Integer. Optional. Default: `0`

Initial gap (empty space) leaved before the first
    partition. Usually is recommended to be 1MB, so GRUB have room to
    write the code needed after the MBR, and the sectors are aligned
    for multiple SSD and hard disk devices. Also is relevant for the
    sector alignment in devices. The valid units are the same for
    `parted`. This value will be used for all the devices if is not
    overwritten.

* `devices`: Dictionary.

List of devices that will be partitioned. We can indicate already
  present devices, like `/dev/sda` or `/dev/hda`, but we can also
  indicate devices that will be present after the RAID configuration,
  like `/dev/md0` or `/dev/md/myraid`. We can use any valid device
  name in Linux such as all the `/dev/disk/by-id/...`,
  `/dev/disk/by-label/...`, `/dev/disk/by-uuid/...` and others.

For each device we have:

* `label`: String. Optional. Default: `msdos`

Partition label for the device. The meaning and the possible
    values are identical for `label` in the `config` section.

* `initial_gap`: Integer. Optional. Default: `0`

Initial gap (empty space) leave before the first partition for
    this device.

* `partitions`: Array. Optional.

Partitions inside a device are described with an array. Each
    element of the array is a dictionary that describe a single
    partition.

* `number`: Integer. Optional. Default: `loop.index`

Expected partition number. Eventually this parameter will be
      really optional, when the partitioner can deduce it from other
      parameters. Today is better to be explicit in the partition
      number, as this will guarantee that the partition is found in
      the hard disk if present. If is not set, number will be the
      current index position in the array.

* `id`: String. Optional.

Full name of the partition. For example, valid ids can be
      `/dev/sda1`, `/dev/md0p1`, etc. Is optional, as the name can be
      deduced from `number`.

* `size`: Float or String.

Size of the partition expressed in `parted` units. All the units
      needs to match for partitions on the same device. For example,
      if `initial_gap` or the first partition is expressed in MB, all
      the sized needs to be expressed in MB too.

The last partition can use the string `rest` to indicate that
      this partition will use all the free space available. If after
      this another partition is defined, Yomi will show a validation
      error.

* `type`: String.

A string that indicate for what this partition will be
      used. Yomi recognize several types:

* `swap`: This partition will be used for SWAP.
      * `linux`: Partition used to root, home or any data.
      * `boot`: Small partition used for GRUB when in BIOS and `gpt`.
      * `efi`: EFI partition used by GRUB when UEFI.
      * `lvm`: Partition used to build an LVM physical volume.
      * `raid`: Partition that will be a component of an array.

Example:

```yaml
partitions:
  config:
    label: gpt
    initial_gap: 1MB
  devices:
    /dev/sda:
      partitions:
        - number: 1
          size: 256MB
          type: efi
        - number: 2
          size: 1024MB
          type: swap
        - number: 3
          size: rest
          type: linux
```

## `lvm` section

To build an LVM we usually create some partitions (in the `partitions`
section) with the `lvm` type set, and in the `lvm` section we describe
the details. This section is a dictionary, were each key is the name
of the LVM volume, and inside it we can find:

* `devices`: Array.

List of components (partitions or full devices) that will constitute
  the physical volumes and the virtual group of the LVM. If the
  element of the array is a string, this will be the name of a device
  (or partition) that belongs to the physical group. If the element is
  a dictionary it will contains:

* `name`: String.

Name of the device or partition.

The rest of the elements of the dictionary will be passed to the
  `pvcreate` command.

Note that the name of the virtual group will be the key where this
  definition is under.

* `volumes`: Array.

Each element of the array will define:

* `name`: String.

Name of the logical volume under the volume group.

The rest of the elements of the dictionary will be passed to the
  `lvcreate` command. For example, `size` and `extents` are used to
  indicate the size of the volume, and they can include a suffix to
  indicate the units. Those units will be the same used for
  `lvcreate`.

The rest of the elements of this section will be passed to the
`vgcreate` command.

Example:

```yaml
lvm:
  system:
    devices:
      - /dev/sda1
      - /dev/sdb1
      - name: /dev/sdc1
        dataalignmentoffset: 7s
    clustered: 'n'
    volumes:
      - name: swap
        size: 1024M
      - name: root
        size: 16384M
      - name: home
        extents: 100%FREE
```

## `raid` section

In the same way that LVM, to create RAID arrays we can setup first
partitions (with the type `raid`) and configure the details in this
section. Also, similar to the LVM section, the keys a correspond to
the name of the device where the RAID will be created. Valid values
are like `/dev/md0` or `/dev/md/system`.

* `level`: String.

RAID level. Valid values can be `linear`, `raid0`, `0`, `stripe`,
   `raid1`, `1`, `mirror`, `raid4`, `4`, `raid5`, `5`, `raid6`, `6`,
   `raid10`, `10`, `multipath`, `mp`, `faulty`, `container`.

* `devices`: Array.

List of devices or partitions that build the array.

* `metadata`: String. Optional. Default: `default`

Metadata version for the superblock. Valid values are `0`, `0.9`,
  `1`, `1.0`, `1.1`, `1.2`, `default`, `ddm`, `imsm`.

The user can specify more parameters that will be passed directly to
`mdadm`, like `spare-devices` to indicate the number of extra devices
in the initial array, or `chunk` to speficy the chunk size.

Example:

```yaml
raid:
  /dev/md0:
    level: 1
    devices:
      - /dev/sda1
      - /dev/sdb1
      - /dev/sdc1
    spare-devices: 1
    metadata: 1.0
```

## `filesystems` section

The partitions, devices or arrays created in previous sections usually
requires a file system. This section will simply list the device name
and the file system (and properties) that will be applied to it.

* `filesystem`. String.

File system to apply in the device. Valid values are `swap`,
  `linux-swap`, `bfs`, `btrfs`, `xfs`, `cramfs`, `ext2`, `ext3`,
  `ext4`, `minix`, `msdos`, `vfat`. Technically Salt will search for a
  command that match `mkfs.<filesystem>`, so the valid options can be
  more extensive that the one listed here.

* `mountpoint`. String.

Mount point where the device will be registered in `fstab`.

* `fat`. Integer. Optional.

If the file system is `vfat` we can force the FAT size, like 12, 16
  or 32.

* `subvolumes`. Dictionary.

For `btrfs` file systems we can specify more details.

* `prefix`. String. Optional.

`btrfs` sub-volume name where the rest of the sub-volumes will be
    under. For example, if we set `prefix` as `@` and we create a
    sub-volume named `var`, Yomi will create it as `@/var`.

* `subvolume`. Dictionary.

* `path`. String.

Path name for the sub-volume.

* `copy_on_write`. Boolean. Optional. Default: `yes`

Value for the copy-on-write option in `btrfs`.

Example:

```yaml
filesystems:
  /dev/sda1:
    filesystem: vfat
    mountpoint: /boot/efi
    fat: 32
  /dev/sda2:
    filesystem: swap
  /dev/sda3:
    filesystem: btrfs
    mountpoint: /
    subvolumes:
      prefix: '@'
      subvolume:
        - path: home
        - path: opt
        - path: root
        - path: srv
        - path: tmp
        - path: usr/local
        - path: var
          copy_on_write: no
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
```

## `bootloader` section

* `device`: String.

Device name where GRUB2 will be installed. Yomi will take care of
  detecting if is a BIOS or an UEFI setup, and also if Secure-Boot in
  activated, to install and configure the bootloader (or the shim
  loader)

* `timeout`: Integer. Optional. Default: `8`

Value for the `GRUB_TIMEOUT` parameter.

* `kernel`: String. Optional. Default: `splash=silent quiet`

Line assigned to the `GRUB_CMDLINE_LINUX_DEFAULT` parameter.

* `terminal`: String. Optional. Default: `gfxterm`

Value for the `GRUB_TERMINAL` parameter.

If the value is set to `serial`, we need to add content to the
  `serial_command` parameter.

If the value is set to `console`, we can pass the console parameters
  to the `kernel` parameter. For example, `kernel: splash=silent quiet
  console=tty0 console=ttyS0,115200`

* `serial_command`: String. Optional

Value for the `GRUB_SERIAL_COMMAND` parameter. If there is a value,
  `GRUB_TERMINAL` is expected to be `serial`.

* `gfxmode`: String. Optional. Default: `auto`

Value for the `GRUB_GFXMODE` parameter.

* `theme`: Boolean. Optional. Default: `no`

If `yes` the `grub2-branding` package will be installed and
  configured.

* `disable_os_prober`: Boolean. Optional. Default: `False`

Value for the `GRUB_DISABLE_OS_PROBER` parameter.

Example:

```yaml
bootloader:
  device: /dev/sda
```

## `software` section

We can indicate the repositories that will be registered in the new
installation, and the packages and patterns that will be installed.

* `config`. Dictionary. Optional

Local configuration for the software section.

* `minimal`: Boolean. Optional. Default: `no`

Configure zypper to make a minimal installation, excluding
    recommended, documentation and multi-version packages.

* `repositories`. Dictionary. Optional

Each key of the dictionary will be the name under where this
  repository is registered, and the key is the URL associated with it.

* `packages`. Array. Optional

List of packages or patters to be installed.

* `image`. Dictionary. Optional

We can bootstrap the root file system based on a partition image
  generate by KIWI (or any other mechanism), that will be copied into
  the partition that have the root mount point assigned. This can be
  used to speed the installation process.
  
  Those images needs to contain only the file system and the data. If
  the image contains a boot loader or partition information, the image
  will fail during the resize operation. To validate if the image is
  suitable, a simple `file image.raw` will do.
  
  * `url`: String.

URL of the image. As internally we are using curl to fetch the
    image, we can support multiple protocols like `http://`,
    `https://` or `tftp://` among others. The image can be compressed,
    and in that case one of those extensions must to be used to
    indicate the format: [`gz`, `bz2`, `xz`]

* `md5`|`sha1`|`sha224`|`sha256`|`sha384`|`sha512`: String. Optional

Checksum type and value used to validate the image. If this field
    is present but empty (only the checksum type, but with no value
    attached), the state will try to fetch the checksum fail from the
    same URL given in the previous field. If the path contains an
    extension for a compression format, this will be replaced with the
    checksum type as a new extension.
	
	For example, if the URL is `http://example.com/image.xz`, the
    checksum type is `md5`, and no value is provided, the checksum
    will be expected at `http://example.com/image.md5`.
	
	But if the URL is something like `http://example.com/image.ext4`,
    the checksum will be expected in the URL
    `http://example.com/image.ext4.md5`.
	
  If the checksum type is provided, the value for the last image will
  be stored in the Salt cache, and will be used to decide if the image
  in the URL is different from the one already copied in the
  partition. If this is the case, no image will be
  downloaded. Otherwise a new image will be copied, and the old one
  will be overwritten in the same partition.

Example:

```yaml
software:
  repositories:
    repo-oss: "http://download.opensuse.org/tumbleweed/repo/oss"
  packages:
    - patterns-base-base
    - kernel-default
```

## `suseconnect` section

Very related with the previous section (`software`), we can register
an SLE product and modules using the `SUSEConnect` command.

In order to `SUSEConnect` to succeed, a product needs to be present
already in the system. This imply that the register must happen after
(at least a partial) installation has been done.

As `SUSEConnect` will register new repositories, this also imply that
not all the packages that can be enumerated in the `software` section
can be installed.

To resolve both conflicts, Yomi will first install the packages listed
in the `sofwtare` section, and after the registration, the packages
listed in this `suseconnect` section.

* `config`. Dictionary.

Local configuration for the section. It is not optional as there is
  at least one parameter that is required for any registration.

* `regcode`. String.

Subscription registration code for the product to be registered.

* `email`. String. Optional.

Email address for product registration.

* `url`. String. Optional.

URL of registration server (e.g. https://scc.suse.com)

* `version`. String. Optional.

Version part of the product name. If the product name do not have a
  version, this default value will be used.

* `arch`. String. Optional.

Architecture part of the product name. If the product name do not
  have an architecture, this default value will be used.

* `products`. Array. Optional.

Product names to register. The expected format is
  <name>/<version>/<architecture>. If only <name> is used, the values
  for <version> and <architecture> will be taken from the `config`
  section.

If the product / module have a different registration code than the
  one declared in the `config` sub-section, we can declare a new one
  via a dictionary.

* `name`. String. Optional.

Product names to register. The expected format is
    <name>/<version>/<architecture>. If only <name> is used, the
    values for <version> and <architecture> will be taken from the
    `config` section.

* `regcode`. String. Optional.

Subscription registration code for the product to be registered.

* `packages`. Array. Optional

List of packages or patters to be installed from the different
  modules.

Example:

```yaml
suseconnect:
  config:
    regcode: SECRET-CODE
  products:
    - sle-module-basesystem/15.2/x86_64
    - sle-module-server-applications/15.2/x86_64
    - name: sle-module-live-patching/15.2/x86_64
      regcode: SECRET-CODE
```

## `salt-minion` section

Install and configure the salt-minion service.

* `config`. Boolean. Optional. Default: `no`

If `yes`, the configuration and cetificates of the new minion will
  be the same that the current minion that is activated. This will
  copy the minion configuration, certificates and grains, together
  with the cached modules and states that are usually synchronized
  before a highstate.

This option will be replaced in the future with more detailed ones.

Example:

```yaml
salt-minion:
  config: yes
```

## `services` section

We can list the services that will be enabled or disabled during boot
time.

* `enabled`. Array. Optional

List of services that will be enabled and started during the boot.

* `disabled`. Array. Optional

List of services that will be exclicitly disabled during the boot.

Example:

```yaml
services:
  enabled:
    - salt-minion
```

## `networks` section

We can list the networks available in the target system. If the list
is not provided, Yomi will try to deduce the network configuration
based on the current setup.

* `interface`. String.

Name of the interface.

Example:

```yaml
networks:
  - interface: ens3
```

## `users` section

In this section we can list a simple list of users and passwords that
we expect to find once the system is booted.

* `username`. String.

* `password`. String. Optional.

Shadow password hash for the user.

* `certificates`. Array. Optional.

Certificates that will be added to .ssh/authorized_keys. Use only
  the encoded key (remove the "ssh-rsa" prefix and the "user@host"
  suffix).

Example:

```yaml
users:
  - username: root
    password: "$1$wYJUgpM5$RXMMeASDc035eX.NbYWFl0"
  - username: aplanas
    certificates:
      - "AAAAB3NzaC1yc2EAAAADAQABAAABAQDdP6oez825gnOLVZu70KqJXpqL4fGf\
        aFNk87GSk3xLRjixGtr013+hcN03ZRKU0/2S7J0T/dICc2dhG9xAqa/A31Qac\
        hQeg2RhPxM2SL+wgzx0geDmf6XDhhe8reos5jgzw6Pq59gyWfurlZaMEZAoOY\
        kfNb5OG4vQQN8Z7hldx+DBANPbylApurVz6h5vvRrkPfuRVN5ZxOkI+LeWhpo\
        vX5XK3eTjetAwWEro6AAXpGoQQQDjSOoYHCUmXzcZkmIWEubCZvAI4RZ+XCZs\
        +wTeO2RIRsunqP8J+XW4cZ28RZBc9K4I1BV8C6wBxN328LRQcilzw+Me+Lfre\
        eDPglqx"
```
07070100000002000081ED0000427000000032000000015F4E04F800005D24000000000000000000000000000000000000003000000000yomi-0.0.1+git.1598948600.9a9eab0/autoyast2yomi#!/usr/bin/python3

# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import argparse
import crypt
import json
import logging
from pathlib import Path
import xml.etree.ElementTree as ET

class PathDict(dict):
    def path(self, path, default=None):
        result = self
        for item in path.split("."):
            if item in result:
                result = result[item]
            else:
                return default
        return result

class Convert:
    def __init__(self, control):
        """Construct a Convert class from a control XML object"""
        self.control = control
        # Store the parsed version of the control file
        self._control = None
        self.pillar = {}

@staticmethod
    def _find(element, name):
        """Find a single element in a XML tree"""
        return element.find("{{http://www.suse.com/1.0/yast2ns}}{}".format(name))

@staticmethod
    def _get_tag(element):
        """Get element name, without namespace"""
        return element.tag.replace("{http://www.suse.com/1.0/yast2ns}", "")

@staticmethod
    def _get_type(element):
        """Get element type if any"""
        return element.attrib.get("{http://www.suse.com/1.0/configns}type")

@staticmethod
    def _get_text(element):
        """Get element text if any"""
        if element is not None and element.text is not None:
            return element.text.strip()

@staticmethod
    def _get_bool(element):
        """Get element boolean value if any"""
        _text = Convert._get_text(element)
        if _text:
            return _text.lower() == "true"

@staticmethod
    def _get_int(element):
        """Get element integer value if any"""
        _text = Convert._get_text(element)
        if _text:
            try:
                return int(_text)
            except ValueError:
                pass

@staticmethod
    def _get(element):
        """Recursively parse the XML tree"""
        type_ = Convert._get_type(element)
        if not type_ and not len(element):
            return Convert._get_text(element)
        elif type_ == "symbol":
            return Convert._get_text(element)
        elif type_ == "boolean":
            return Convert._get_bool(element)
        elif type_ == "integer":
            return Convert._get_int(element)
        elif type_ == "list":
            return [Convert._get(subelement) for subelement in element]
        elif not type_ and len(element):
            return {
                Convert._get_tag(subelement): Convert._get(subelement)
                for subelement in element
            }
        else:
            logging.error("Element type not recognized: %s", type_)

@staticmethod
    def _parse(element):
        """Parse the XML tree entry point"""
        return PathDict({Convert._get_tag(element): Convert._get(element)})

def convert(self):
        """Transform a XML control file into a Yomi pillar"""
        self._control = Convert._parse(self.control.getroot())
        self._convert_config()
        self._convert_partitions()
        self._convert_lvm()
        self._convert_raid()
        self._convert_filesystems()
        self._convert_bootloader()
        self._convert_software()
        self._convert_suseconnect()
        self._convert_salt_minion()
        self._convert_services()
        self._convert_users()
        return self.pillar

def _reboot(self):
        """Detect if a reboot is required"""
        reboot = False
        mode = self._control.path("profile.general.mode", {})
        if mode.get("final_halt") or mode.get("halt"):
            reboot = "shutdown"
        elif mode.get("final_reboot") or mode.get("forceboot"):
            reboot = True
        return reboot

def _snapper(self):
        """Detect if snapper is required"""
        partitioning = self._control.path("profile.partitioning", PathDict())
        snapper = any(
            drive.get("enable_snapshots", True)
            for drive in partitioning
            if any(
                partition
                for partition in drive.get("partitions", [])
                if partition.get("filesystem", "btrfs") == "btrfs"
            )
        )

snapper |= self._control.path("profile.bootloader.suse_btrfs", False)
        return snapper

def _keymap(self):
        """Translate keymap configuration"""
        keymap = self._control.path("profile.keyboard.keymap", "english-us")
        return {
            "english-us": "us",
            "english-uk": "gb",
            "german": "de-nodeadkeys",
            "german-deadkey": "de",
            "german-ch": "ch",
            "french": "fr",
            "french-ch": "ch-fr",
            "french-ca": "ca",
            "cn-latin1": "ca-multix",
            "spanish": "es",
            "spanish-lat": "latam",
            "spanish-lat-cp850": "es",
            "spanish-ast": "es-ast",
            "italian": "it",
            "persian": "ir",
            "portugese": "pt",
            "portugese-br": "br",
            "portugese-br-usa": "us-intl",
            "greek": "gr",
            "dutch": "nl",
            "danish": "dk",
            "norwegian": "no",
            "swedish": "se",
            "finnish": "fi-kotoistus",
            "czech": "cz",
            "czech-qwerty": "cz-qwerty",
            "slovak": "sk",
            "slovak-qwerty": "sk-qwerty",
            "slovene": "si",
            "hungarian": "hu",
            "polish": "pl",
            "russian": "ruwin_alt-UTF-8",
            "serbian": "sr-cy",
            "estonian": "ee",
            "lithuanian": "lt",
            "turkish": "tr",
            "croatian": "hr",
            "japanese": "jp",
            "belgian": "be",
            "dvorak": "us-dvorak",
            "icelandic": "is",
            "ukrainian": "ua-utf",
            "khmer": "khmer",
            "korean": "kr",
            "arabic": "arabic",
            "tajik": "tj_alt-UTF8",
            "taiwanese": "us",
            "chinese": "us",
            "romanian": "ro",
            "us-int": "us-intl",
        }.get(keymap, "us")

def _convert_config(self):
        """Convert the config section of a pillar"""
        config = self.pillar.setdefault("config", {})

# Missing fields:
        #  * locale_message
        #  * machine_id

config["events"] = True
        config["reboot"] = self._reboot()
        config["snapper"] = self._snapper()
        config["locale"] = self._control.path("profile.language.language", "en_US.utf8")
        config["keymap"] = self._keymap()
        config["timezone"] = self._control.path("profile.timezone.timezone", "UTC")
        hostname = self._control.path("profile.networking.dns.hostname")
        if hostname:
            config["hostname"] = hostname
        config["target"] = self._control.path(
            "profile.services-manager.default_target", "multi-user.target"
        )

def _size(self, partition):
        """Detect the size of a partition"""
        size = partition.get("size")
        return "rest" if size == "max" or not size else size

def _type(self, partition):
        """Detect the type of a partition"""
        partition_id = partition.get("partition_id")
        if not partition_id:
            filesystem = partition.get("filesystem")
            if filesystem or partition.get("mount"):
                partition_id = 130 if filesystem == "swap" else 131
            elif partition.get("lvm_group"):
                partition_id = 142
            elif partition.get("raid_name"):
                partition_id = 253
            else:
                # 'boot' type if is not a file system, LVM, nor RAID
                return "boot"
        return {130: "swap", 131: "linux", 142: "lvm", 253: "raid", 259: "efi"}[
            partition_id
        ]

def _label(self, drive):
        """Detect the kind of partition table of a device"""
        disklabel = drive.get("disklabel", "gpt")
        if disklabel and disklabel != "none" and not drive.get("raid_options"):
            return disklabel

def _convert_partitions(self):
        """Convert the partitions section of a pillar"""
        partitions = self.pillar.setdefault("partitions", {})

for drive in self._control.path("profile.partitioning", []):
            # If is part of a logical volume, we skip the drive
            if drive.get("is_lvm_vg"):
                continue

# If the device is missing, we cannot build the pillar
            device = drive.get("device")
            if not device:
                logging.error("Device missing in partitioning")
                continue

devices = partitions.setdefault("devices", {})
            _device = devices.setdefault(device, {})

label = self._label(drive)
            if label:
                _device["label"] = label

_partitions = _device.setdefault("partitions", [])

for index, partition in enumerate(drive.get("partitions", [])):
                _partition = {}
                _partition["number"] = partition.get("partition_nr", index + 1)
                _partition["size"] = self._size(partition)
                _partition["type"] = self._type(partition)

if _partition:
                    _partitions.append(_partition)

def _convert_lvm(self):
        """Convert the lvm section of a pillar"""
        lvm = {}

for drive in self._control.path("profile.partitioning", []):
            # If the device is missing, we cannot build the pillar
            device = drive.get("device")
            if not device:
                logging.error("Device missing in partitioning")
                continue

if drive.get("is_lvm_vg"):
                lvm_group = Path(device).name
                group = lvm.setdefault(lvm_group, {})
                volumes = group.setdefault("volumes", [])
                for partition in drive.get("partitions", []):
                    volumes.append(
                        {"name": partition["lv_name"], "size": partition["size"]}
                    )
                # Group parameters
                pesize = drive.get("pesize")
                if pesize:
                    group["physicalextentsize"] = pesize
            else:
                for index, partition in enumerate(drive.get("partitions", [])):
                    lvm_group = partition.get("lvm_group")
                    if lvm_group:
                        partition_nr = partition.get("partition_nr", index + 1)
                        group = lvm.setdefault(lvm_group, {})
                        devices = group.setdefault("devices", [])
                        devices.append("{}{}".format(device, partition_nr))

if lvm:
            self.pillar["lvm"] = lvm

def _convert_raid(self):
        """Convert the raid section of a pillar"""
        raid = {}

raid_options = drive.get("raid_options")
            if raid_options:
                _device = raid.setdefault(device, {})
                chunk_size = raid_options.get("chunk_size")
                if chunk_size:
                    _device["chunk"] = chunk_size
                parity_algorithm = raid_options.get("parity_algorithm")
                if parity_algorithm:
                    _device["parity"] = parity_algorithm.replace("_", "-")
                _device["level"] = raid_options.get("raid_type", "raid1")
                device_order = raid_options.get("device_order")
                if device_order:
                    _device["devices"] = device_order
                continue

for index, partition in enumerate(drive.get("partitions", [])):
                raid_name = partition.get("raid_name")
                if raid_name:
                    partition_nr = partition.get("partition_nr", index + 1)
                    _device = raid.setdefault(raid_name, {})
                    devices = _device.setdefault("devices", [])
                    devices.append("{}{}".format(device, partition_nr))

if raid:
            self.pillar["raid"] = raid

def _convert_filesystems(self):
        filesystems = self.pillar.setdefault("filesystems", {})

for index, partition in enumerate(drive.get("partitions", [])):
                filesystem = {}

if drive.get("is_lvm_vg"):
                    lv_name = partition["lv_name"]
                    _partition = str(Path(device, lv_name))
                elif drive.get("raid_options"):
                    partition_nr = partition.get("partition_nr", index + 1)
                    _partition = "{}p{}".format(device, partition_nr)
                else:
                    partition_nr = partition.get("partition_nr", index + 1)
                    _partition = "{}{}".format(device, partition_nr)

_filesystem = partition.get("filesystem")
                if _filesystem:
                    filesystem["filesystem"] = _filesystem

mount = partition.get("mount")
                if mount:
                    filesystem["mountpoint"] = mount

subvolumes = partition.get("subvolumes")
                if _filesystem == "btrfs" and subvolumes:
                    _subvolumes = filesystem.setdefault("subvolumes", {})
                    _subvolumes["prefix"] = partition.get("subvolumes_prefix", "@")

subvolume = _subvolumes.setdefault("subvolume", [])
                    for _subvolume in subvolumes:
                        if isinstance(_subvolume, str):
                            subvolume.append({"path": _subvolume})
                        else:
                            subvolume.append(_subvolume)

if _partition and filesystem:
                    filesystems[_partition] = filesystem

def _kernel(self, bootloader_global):
        append = bootloader_global.get("append", "")
        cpu_mitigations = bootloader_global.get("cpu_mitigations", "")
        if cpu_mitigations:
            cpu_mitigations = (
                "noibrs noibpb nopti nospectre_v2 nospectre_v1 "
                "l1tf=off nospec_store_bypass_disable "
                "no_stf_barrier mds=off mitigations=off"
            )
        else:
            cpu_mitigations = ""
        vgamode = bootloader_global.get("vgamode", "")
        if vgamode and vgamode not in append:
            vgamode = "vga={}".format(vgamode)
        else:
            vgamode = ""

return " ".join(
            param
            for param in ("splash=silent quiet", append, cpu_mitigations, vgamode)
            if param
        )

def _convert_bootloader(self):
        """Convert the bootloader section of the pillar"""
        bootloader = self.pillar.setdefault("bootloader", {})

_global = self._control.path("profile.bootloader.global", {})

# TODO: If EFI, we will be sure to create a EFI partition

# TODO: `boot_custom` is not used to store the device
        device = _global.get("boot_custom")
        if device:
            bootloader["device"] = device
        else:
            logging.error("Bootloader device not found in control file")

timeout = _global.get("timeout")
        if timeout:
            bootloader["timeout"] = timeout

bootloader["kernel"] = self._kernel(_global)

terminal = _global.get("terminal")
        if terminal:
            bootloader["terminal"] = terminal

serial = _global.get("serial")
        if serial:
            bootloader["serial_command"] = serial

gfxmode = _global.get("gfxmode")
        if gfxmode:
            bootloader["gfxmode"] = gfxmode

bootloader["theme"] = True

os_prober = _global.get("os_prober")
        if os_prober is not None:
            bootloader["disable_os_prober"] = not os_prober

def _repositories(self, add_on):
        return {
            entry["alias"]: entry["media_url"]
            for add_on_type in ("add_on_products", "add_on_others")
            for entry in add_on.get(add_on_type, [])
        }

def _packages(self, software, include_pre, include_post):
        packages = []

if include_pre:
            for product in software.get("products", []):
                packages.append("product:{}".format(product))

if include_pre:
            for pattern in software.get("patterns", []):
                packages.append("pattern:{}".format(pattern))

if include_post:
            for pattern in software.get("post-patterns", []):
                packages.append("pattern:{}".format(pattern))

if include_pre:
            for package in software.get("packages", []):
                packages.append(package)

if include_post:
            for package in software.get("post-packages", []):
                packages.append(package)

kernel = software.get("kernel")
        if include_pre and kernel:
            packages.append(kernel)

return packages

def _convert_software(self):
        """Convert the software section of the pillar"""
        software = self.pillar.setdefault("software", {})

_software = self._control.path("profile.software", {})

install_recommended = _software.get("install_recommended")
        if install_recommended is not None:
            config = software.setdefault("config", {})
            config["minimal"] = not install_recommended

add_on = self._control.path("profile.add-on", {})
        if not add_on:
            logging.error("No repositories will be registered")
        software["repositories"] = self._repositories(add_on)
        software["packages"] = self._packages(
            _software,
            include_pre=True,
            include_post="suse_register" not in self._control["profile"],
        )

def _products(self, suse_register):
        products = []

for addon in suse_register.get("addons", []):
            products.append("/".join((addon["name"], addon["version"], addon["arch"])))

return products

def _convert_suseconnect(self):
        """Convert the suseconnect section of the pillar"""
        suseconnect = self.pillar.get("suseconnect", {})

suse_register = self._control.path("profile.suse_register", {})

if not suse_register:
            return

config = suseconnect.setdefault("config", {})

reg_code = suse_register.get("reg_code")
        if reg_code:
            config["regcode"] = reg_code

email = suse_register.get("email")
        if email:
            config["email"] = email

reg_server = suse_register.get("reg_server")
        if reg_server:
            config["url"] = reg_server

suseconnect["products"] = self._products(suse_register)

software = self._control.path("profile.software", {})
        packages = self._packages(software, include_pre=False, include_post=True)
        if packages:
            suseconnect["packages"] = packages

if suseconnect:
            self.pillar["suseconnect"] = suseconnect

def _convert_salt_minion(self):
        """Convert the salt-minion section of the pillar"""
        self.pillar.setdefault("salt-minion", {"configure": True})

def _services(self, services):
        _services = []
        for service in services:
            if not service.endswith((".service", ".socket", ".timer")):
                service = "{}.service".format(service)
            _services.append(service)

return _services

def _convert_services(self):
        """Convert the services section of the pillar"""
        services = self.pillar.get("services", {})

enable = self._control.path("profile.services-manager.services.enable", [])
        for service in self._services(enable):
            services.setdefault("enabled", []).append(service)

disable = self._control.path("profile.services-manager.services.disable", [])
        for service in self._services(disable):
            services.setdefault("disabled", []).append(service)

on_demand = self._control.path(
            "profile.services-manager.services.on_demand", []
        )
        for service in self._services(on_demand):
            services.setdefault("enabled", []).append(
                service.replace(".service", ".socket")
            )
            services.setdefault("disabled", []).append(service)

if services:
            self.pillar["services"] = services

@staticmethod
    def _password(user, salt=None):
        password = user.get("user_password")
        if password and not user.get("encrypted"):
            salt = salt if salt else crypt.mksalt(crypt.METHOD_MD5)
            password = crypt.crypt(password, salt)
        return password

def _certificates(self, user):
        certificates = []
        for certificate in user.get("authorized_keys", []):
            parts = certificate.split()
            for index, part in enumerate(parts):
                if part in ("ssh-rsa", "ssh-dss", "ssh-ed25519") or part.startswith(
                    "ecdsa-sha"
                ):
                    certificates.append(parts[index + 1])
                    break

return certificates

def _convert_users(self):
        """Convert the users section of the pillar"""
        users = self.pillar.get("users", [])

# TODO parse the fullname, uid, gid, etc. fields

_users = self._control.path("profile.users", [])
        for _user in _users:
            user = {"username": _user["username"]}

password = Convert._password(_user)
            if password:
                user["password"] = password

certificates = self._certificates(_user)
            if certificates:
                user["certificates"] = certificates

users.append(user)

if users:
            self.pillar["users"] = users

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Convert AutoYaST control files")
    parser.add_argument("control", metavar="CONTROL.XML", help="autoyast control file")
    parser.add_argument(
        "-o", "--out", default="yomi.json", help="output file (default: yomi.json)"
    )

args = parser.parse_args()
    control = ET.parse(args.control)
    convert = Convert(control)
    pillar = convert.convert()
    with open(args.out, "w") as f:
        json.dump(pillar, f, indent=4)
07070100000003000041ED0000427000000032000000035F4E04F800000000000000000000000000000000000000000000002700000000yomi-0.0.1+git.1598948600.9a9eab0/docs07070100000004000081A40000427000000032000000015F4E04F8000018CB000000000000000000000000000000000000004300000000yomi-0.0.1+git.1598948600.9a9eab0/docs/appendix-how-to-use-qemu.md# Appendix: How to use QEMU to test Yomi

We can use libvirt, VirtualBox or real hardware to test Yomi. In this
appendix we will give the basic instructions to setup QEMU with KVM to
create a local network that will enable the communication of the nodes
between each other, and with the guest.

## General overview

We will use `qemu-system-x86_64` and the OVMF firmware to deploy UEFI
nodes, and `socat` and `dnsmasq` to build a local network where our
nodes can communicate.

With QEMU we usually need to create some bridges and tun/tap
interfaces that enable the communication between the local
instances. To provide external access to those instances, we also
usually need to enable the masquerading via `iptables`, and
`ip_forward` via `sysctl` in out host. But using `socat` and `dnsmasq`
we can avoid this.

For this to work we will need two interfaces in the virtual
machine. One will be owned by QEMU, that will use the user networking
(SLIRP) back-end. In this network mode, the interface will have always
the IP 10.0.2.15 in the VM side, and the host is reachable via the
10.0.2.2 IP. There is also an internal DNS under the IP 10.0.2.3, that
is managed by QEMU and cannot be configured.

SLIRP is optional and more complicated QEMU deployments disable this
back-end by default. But for us is an easy way to have a connection
between the VM and the host.

If we maintain SLIPR operational, all the VMs will have the same IP,
and all of them will see the host machine via the same IP too, but
they cannot see each other. To resolve this we can add a second
virtual interface in the VM, that using multi-cast, will be used as a
communication channel between the VMs.

We will need to use to external tools to enable this multi-cast
communication. One, `socat`, will create a new virtual interface named
`vmlan` in the host, where all the VMs will be connected to. And the
other is `dnsmasq`, that will be used as a local DHCP / DNS server
that will work on this new interface.

### Creating the local network

First we will need to install both tools:

```bash
zypper in socat dnsmasq
```

Now we need to use `socat` to create a new virtual interface named
`vmlan`, that will expose the IP 10.0.3.1 to the host. At the other
side we will have the multicast socket from QEMU.

```bash
sudo socat \
  UDP4-DATAGRAM:230.0.0.1:1234,sourceport=1234,reuseaddr,ip-add-membership=230.0.0.1:127.0.0.1 \
  TUN:10.0.3.1/24,tun-type=tap,iff-no-pi,iff-up,tun-name=vmlan
```

If you see the error `Network is unreachable`, check if all the
interfaces have an IP assigned (this can be the case when running
inside a VM). But if the error message is `Device or resource busy`,
check that there is not a previous `socat` process running for the
same connection.

Move this process in a second plane, and check that via `ip a s` we
have the `vmlan` interface.

We will now attach a DHCP / DNS server to this new interface, so the
new nodes will have a predicted IP and hostname. Also the nodes will
find the master using a name that can be resolved.

```bash
sudo dnsmasq --no-daemon \
             --interface=vmlan \
             --except-interface=lo \
             --except-interface=em1 \
             --bind-interfaces \
             --dhcp-range=10.0.3.100,10.0.3.200 \
             --dhcp-option=option:router,10.0.3.101 \
             --dhcp-host=00:00:00:11:11:11,10.0.3.101,master \
             --dhcp-host=00:00:00:22:22:22,10.0.3.102,worker1 \
             --dhcp-host=00:00:00:33:33:33,10.0.3.103,worker2 \
             --host-record=master,10.0.3.101
```

This command will deliver IPs into the interface `vmlan` from the
range 10.0.3.100 to 10.0.3.200. The service will ignore the petitions
from the local host and the `em1` interface. If your interfaces are
named differently, you will need to adjust the command accordingly.

The hostnames `master`, `worker1` and `worker2` will be assigned based
on the MAC address, and `master` name will be always resolved to
10.0.3.101. This will simplify the configuration of the salt-minion
later.

### Connecting QEMU to the new network

We can now launch QEMU to have two interfaces. One will be connected
to the new `vmlan` network, via the multi-cast socket option, and the
other interface will be connected to the host machine.

Because we will use UEFI, we will need first to copy the OVMF firmware
locally.

```bash
cp /usr/share/qemu/ovmf-x86_64-code.bin .
cp /usr/share/qemu/ovmf-x86_64-vars.bin .
```

Now we can launch QEMU:

```bash
# Local copy for the variable OVMF file
cp -af ovmf-x86_64-vars.bin ovmf-x86_64-vars-node.bin

# Create the file that will be used as a hard-disk
qemu-img create -f qcow2 hda-node.qcow2 50G

qemu-system-x86_64 -m 2048 -enable-kvm \
  -netdev socket,id=vmlan,mcast=230.0.0.1:1234 \
  -device virtio-net-pci,netdev=vmlan,mac=00:00:00:11:11:11 \
  -netdev user,id=net0,hostfwd=tcp::10022-:22 \
  -device virtio-net-pci,netdev=net0,mac=10:00:00:11:11:11 \
  -cdrom *.iso \
  -hda hda-node.qcow2 \
  -drive if=pflash,format=raw,unit=0,readonly,file=./ovmf-x86_64-code.bin \
  -drive if=pflash,format=raw,unit=1,file=./ovmf-x86_64-vars-node.bin \
  -smp 2 \
  -boot d &
```

The first interface will be connected to the `vmlan` via a multi-cast
socket. The second interface will be the SLIRP user network mode, that
will be connected to the host. We also forward the local port `10022`
to the port `22` in the VM. So we can SSH into the node with:

```bash
ssh root@localhost -p 10022
```

# PXE Boot with QEMU

We can configure `dnsmasq` also to serve the TFTP assets that are
required for the [PXE Boot](../README.md#pxe-boot) image. For example,
this can be used as a base for a local server:

```bash
mkdir tftpboot
sudo ./dnsmasq --no-daemon \
               --interface=vmlan \
               --except-interface=lo \
               --except-interface=em1 \
               --bind-interfaces \
               --dhcp-range=10.0.3.100,10.0.3.200 \
               --dhcp-option=option:router,10.0.3.101 \
               --dhcp-host=00:00:00:11:11:11,10.0.3.101,worker \
               --host-record=master,10.0.2.2 \
               --enable-tftp \
               --dhcp-boot=pxelinux.0,,10.0.3.1 \
               --tftp-root=$(pwd)/tftpboot
```

Follow the documentation to create the different configuration files
and copy the assets in the correct places.
07070100000005000041ED0000427000000032000000035F4E04F800000000000000000000000000000000000000000000003000000000yomi-0.0.1+git.1598948600.9a9eab0/docs/examples07070100000006000041ED0000427000000032000000045F4E04F800000000000000000000000000000000000000000000003600000000yomi-0.0.1+git.1598948600.9a9eab0/docs/examples/kubic07070100000007000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/docs/examples/kubic/kubic07070100000008000081A40000427000000032000000015F4E04F8000005B1000000000000000000000000000000000000004E00000000yomi-0.0.1+git.1598948600.9a9eab0/docs/examples/kubic/kubic/control_plane.sls{% import 'macros.yml' as macros %}

{% set users = pillar['users'] %}
{% set public_ip = grains['ip4_interfaces']['ens3'][0] %}

{{ macros.log('module', 'install_kubic') }}
install_kubic:
  module.run:
    - kubeadm.init:
        - apiserver_advertise_address: {{ public_ip }}
        - pod_network_cidr: '10.244.0.0/16'
    - creates: /etc/kubernetes/admin.conf

{% for user in users %}
  {% set username = user.username %}
{{ macros.log('file', 'create_kubic_directory_' ~ username) }}
create_kubic_directory_{{ username }}:
  file.directory:
    - name: ~{{ username }}/.kube
    - user: {{ username }}
    - group: {{ username if username == 'root' else 'users' }}
    - mode: 700

{{ macros.log('file', 'copy_kubic_configuration_' ~ username) }}
copy_kubic_configuration_{{ username }}:
  file.copy:
    - name: ~{{ username }}/.kube/config
    - source: /etc/kubernetes/admin.conf
    - user: {{ username }}
    - group: {{ username if username == 'root' else 'users' }}
    - mode: 700
{% endfor %}

{{ macros.log('cmd', 'install_network') }}
install_network:
  cmd.run:
    - name: kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/bc79dd1505b0c8681ece4de4c0d86c5cd2643275/Documentation/kube-flannel.yml
    - unless: ip link | grep -q flannel

{% set users = pillar['users'] %}
{% set join_params = salt.mine.get(tgt='00:00:00:11:11:11', fun='join_params')['00:00:00:11:11:11'] %}

{{ macros.log('module', 'join_control_plane') }}
join_control_plane:
  module.run:
    - kubeadm.join:
        - api_server_endpoint: {{ join_params['api-server-endpoint'] }}
        - discovery_token_ca_cert_hash: {{ join_params['discovery-token-ca-cert-hash'] }}
        - token: {{ join_params['token'] }}
    - creates: /etc/kubernetes/kubelet.conf

{{ macros.log('loop', 'wait_interfaces_up') }}
wait_interfaces_up:
  loop.until:
    - name: network.interfaces
    - condition: "'flannel.1' in m_ret"
    - period: 5
    - timeout: 300
0707010000000A000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1598948600.9a9eab0/docs/examples/kubic/orch0707010000000B000081A40000427000000032000000015F4E04F800000345000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/docs/examples/kubic/orch/kubic.slssynchronize_all:
  salt.function:
    - name: saltutil.sync_all
    - tgt: '*'

install_microos:
  salt.state:
    - sls:
      - yomi
    - tgt: '*'

wait_for_reboots:
  salt.wait_for_event:
    - name: salt/minion/*/start
    - id_list:
      - '00:00:00:11:11:11'
      - '00:00:00:22:22:22'
    - require:
      - salt: install_microos

install_control_plane:
  salt.state:
    - tgt: '00:00:00:11:11:11'
    - sls:
      - kubic.control_plane

send_mine:
  salt.function:
    - name: mine.send
    - tgt: '00:00:00:11:11:11'
    - arg:
      - join_params
    - kwarg:
        mine_function: kubeadm.join_params
        create_if_needed: yes

join_worker:
  salt.state:
    - tgt: '00:00:00:22:22:22'
    - sls:
      - kubic.join

delete_mine:
  salt.function:
    - name: mine.delete
    - tgt: '*'
    - arg:
      - join_params
0707010000000C000081A40000427000000032000000015F4E04F80000176E000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/docs/use-case-as-a-kubic-worker.md# Use Case: A Kubic worker provisioned with Yomi

We can use [Yomi](https://github.com/openSUSE/yomi) to deploy worker
nodes in an already deployed Kubic cluster.

## Overview and requirements

In this section we are going to describe a way to deploy a two-node
Kubic cluster, and use Yomi to provision a third node.

For this example we can use `libvirt`, `virtualbox`, `vagrant` or
`QEMU`.

We will need to allocate three VMs with:

* 50GB of hard disk
* 2 CPU per node
* 2048MB RAM per system

We will need also connectivity bewteen the different VMs to form a
local network, and also access to Internet for downloading packages.

You can check
[appendix-how-to-use-qemu.md](appendix-how-to-use-qemu.md) to learn
about how to do this with QEMU and how to setup a DNS server with
`dnsmasq` to create a network configuration that will meet the
requirements.

## Installing MicroOS for Kubic

Follow the documentation about how to install a two node Kubic cluster
from the [Kubic
documentation](https://en.opensuse.org/Kubic:kubeadm). In a nutshell
the process is:

* Spin two empty nodes with QEMU / libvirt
* Boot both nodes using the [Kubic
  image](http://download.opensuse.org/tumbleweed/iso/openSUSE-Kubic-DVD-x86_64-Current.iso)
* Deploy one node with the 'Kubic Admin Node' role, this will install
  CRI-O, `kubeadn` and `kubicctl`, together with `salt-master`.
* Deploy the second node with the system role 'Kubic Worker Node'.

We will use `kubicctl` to deploy Kubernetes in the control plane, and
use this same tool to join the already installed worker.

If the control plane node have more that one interface (for example,
if we use QEMU as described in the appendix documentation this will be
the case, but not if we use libvirt), we need to identify the one that
is visible from the worker node. We will pass the IP of this interface
via the `--adv-addr` parameter.

```bash
kubicctl init --adv-addr 10.0.3.101
```

If there are not multiple interfaces and we want to use `flannel` as a
pod network, as simple `kubicctl init` will work on most of the cases.

In the worker node we need to set up `salt-minion` so in can connect
to the `salt-master` in the control plane node. We need to find the
address or IP address that can be used to point to the master,
configure the minion and restart the service.

```bash
echo "master: <MASTER-IP>" > /etc/salt/minion.d/master.conf
systemctl enable --now salt-minion.service
```

The minion now try to connect to the master, but before this can
succeed we need to accept the key in the `master` node.

```bash
salt-key -A
```

We can test from the master that the minion is answering properly:

```bash
salt worker1 test.ping
```

Now we can join the node from the `master` one:

```bash
kubicctl node add worker1
```

Note that `worker1` is refers here to the minion ID that Salt
recognize, not the host name of the worker node.

If the command succeed, we inspect the cluster status:

```bash
kubectl get nodes
```

It will show something like:

```
NAME      STATUS   ROLES    AGE   VERSION
master    Ready    master   11m   v1.15.0
worker1   Ready    <none>   56s   v1.15.0
```

If `kubectl` fails, check that `/etc/kubernetes/admin.conf` is copied
as `~/.kube/config` as documented in `kubeadm`.

## Provisioning a Kubic worker with Yomi

The first worker was allocated via the Kubic DVD image. This is
reasonable for small clusters, but we can simplify the work if we can
install MicroOS on new nodes using SaltStack and later join the node
to the cluster with `kubicctl`.

### Yomi image and Yomi package

Yomi is a set of Salt states that will allows the provisioning of
systems. We will need to boot the new node using a JeOS image that
contains a `salt-minion` service, that later can be controlled from
the `master` node, that is where `salt-master` is installed.

You can find mode information about this Yomi image in the [Booting a
new machine](../README.md#booting-a-new-machine) section if the main
documentation.

Download the ISO image or the PXE Boot one (check the previous link
the learn how to configure the PXE Boot one). Optionally configure the
`salt-master` to enable the auto-sign feature via UUID, as described
in the [Enabling auto-sign](../README.md#enabling-auto-sign) section.

In the `master` node we will need to install the `yomi-formula`
package from Factory.

```bash
transactional-update pkg install yomi-formula
reboot
```

We can now boot a new node in the same network that the Kubic cluster,
using the Yomi image. Be sure (via boot parameter or later
configuration) that the `salt-minion` can find the already present
master, and if needed accept the key.

### Adding the new worker

We need to set the pillar data that Yomi will use to make a new
installation. This data will describe installation details like how
will be the hard disk partition layout, the different packages that
will be installed or the services that will be enabled before booting.

The packages `yomi-formula` already provides and example for a MicroOS
installation, so we can use it as a template.

Read the section [Configuring the
pillar](../README.md#configuring-the-pillar) to learn more about the
pillar examples provided by the package, and how to copy them in a
place that we can edit them.

The `yomi-formula` package do not include an example `top.sls`, but we
can create one easily for this example.

```bash
cat <<EOF > /srv/salt/top.sls
base:
  '*':
    - yomi
EOF
```

Check also that for the pillar we also have a `top.sls`. The one that
we have in the package as an example is:

```yaml
base:
  '*':
    - installer
```

Now we can [get information about the
hardware](../README.md#getting-hardware-information) available in the
new worker node, and adjust the pillar accordingly.

Optionally we can [wipe the disks](../README.md#cleaning-the-disks),
and then apply the `yomi` state.

```bash
salt worker2 state.apply
```

Once the node is back, we can proceed as usual:

```bash
kubicctl node add worker2
```
0707010000000D000081A40000427000000032000000015F4E04F80000132C000000000000000000000000000000000000005000000000yomi-0.0.1+git.1598948600.9a9eab0/docs/use-case-deploying-kubic-from-scratch.md# Use Case: Deployment of Kubic from scratch

We can use [Yomi](https://github.com/openSUSE/yomi) to deploy the
control plane and the workers of a new Kubic cluster using SaltStack
to orchestrate the installation.

## Deploying a Kubic control plane node with Yomi

In this section we are going to describe a way to deploy a two-node
Kubic cluster from scratch. One node will be the controller or the
Kubic cluster, and the second node will be the worker.

For this example we can use `libvirt`, `virtualbox`, `vagrant` or
`QEMU`.

We will need to allocate two VMs with:

* 50GB of hard disk
* 2 CPU per node
* 2048MB RAM per system

We will need also connectivity bewteen the different VMs to form a
local network, and also access to Internet for downloading packages.

The general process will be to install a local `salt-master`, that
will be used to first install MicroOS in the two VMs. Later we will
use a [Salt
orchestrator](https://docs.saltstack.com/en/latest/topics/orchestrate/orchestrate_runner.html)
to provision the operating system and install the different Kubic
components via `kubeadm`. One node of the cluster will be for the
control plane, and the second one will be a worker.

## Installing salt-master and yomi-formula

We need to install locally the `salt-master` and the `yomi-formula`
packages, as we will control the installation from out laptop or
desktop machine.

```bash
sudo zypper in salt-master salt-standalone-formulas-configuration
sudo zypper in yomi-formula
```

## Configuring salt-master

We are going to use the states from Yomi that are living in
`/usr/share/salt-formulas/yomi`, and some other states are are in
`/usr/share/yomi/kubic`. In order to make both location reachable, we
need to configure `salt-master`.

```bash
sudo cp -a /usr/share/yomi/kubic-file.conf /etc/salt/master.d/
sudo cp -a /usr/share/yomi/pillar.conf /etc/salt/master.d/
```

Optionally, we will configure autosign via UUID, so we can avoid
accept the new `salt-minion` keys during the exercise.

```bash
sudo cp /usr/share/yomi/autosign.conf /etc/salt/master.d/
```

We can now restart the service:

```bash
systemctl restart salt-master.service
```

For a more detailed description read the sections [Looking for the
pillar](../README.md#looking-for-the-pillar) and [Enabling
auto-sign](../README.md#enabling-auto-sign) in the documentation.

## Orchestrating the Kubic installation

Now we can launch two nodes via `libvirt` or `QEMU`. For this last
option read the document [How to use
QEMU](appendix-how-to-use-qemu.md) to take some ideas and make the
proper adjustments on `dnsmasq` to assign correct names for the
different nodes.

You need to boot both nodes with the ISO image or the PXE Boot one,
and check that you can see them locally:

```bash
salt '*' test.ping
```

If something goes wrong check this in order:

1. `master` can be resolved from the nodes
2. `salt-minion` service is running correctly
3. There is no old key in the master (`salt-key '*' -D`)

Adjust the `kubic.sls` from the states to reference properly the
nodes. The provided example is using the MAC address to reference the
nodes:

* `00:00:00:11:11:11`: Control plane node
* `00:00:00:22:22:22`: Worker node

Now we can orchestrate the Kubic installation. So from your host
machine where `salt-master` is running we can fire the orchestrator.

```bash
salt-run state.orchestrate orch.kubic
```

This will execute commands in the `salt-master`, that will:

1. Synchronize all the execution modules, pillars and grains
2. Install MicroOS in both nodes
3. Wait for the reboot of both nodes
4. Install the control plane in `00:00:00:11:11:11`
5. Send a mine to the control plane node, that will collect the
   connection secrets
6. Join the worker (`00:00:00:22:22:22`) using `kubeadm` and those
   secrets
7. Remove the mine

This orchestrator is only an example, and there are elements that can
be improved. The main one is that inside the YAML file there are
references to the minion ID of the control plane and the worker,
something that is better to put in the pillar.

Another problem is that in the current version of Salt, we cannot send
asynchronous commands to the orchestrator. This imply that there is a
race condition in the section that wait for the node reboot. If one
node reboot before than the other, there is a chance that the reboot
event will be lost before the `salt.wait_for_event` is reached. The
next version of Salt, Neon, will add this capability, and the example
will be updated accordingly.

If this race condition happens, you can wait manually to the reboot,
comment the `salt.wait_for_event` entry in `kubic.sls`, and relaunch
the `salt-run` command.
0707010000000E000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000002B00000000yomi-0.0.1+git.1598948600.9a9eab0/metadata0707010000000F000081A40000427000000032000000015F4E04F800006D28000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/metadata/01-form-yomi.yml# Uyuni Form for the Yomi pillar data - Main section
#
# Find mode pillar examples in /usr/share/yomi/pillar

config:
  $name: General Configuration
  $type: group
  $help: General Configuration Section for the Yomi Formula
  events:
    $type: boolean
    # Change default once Uyuni can track the events
    $default: no
    $help: If set, the installation can be monitored via Salt events
  reboot:
    $type: select
    $values:
      - "yes"
      - "no"
      - kexec
      - halt
      - shutdown
    $default: "yes"
    $help: Kind of reboot at the end of the installation
  snapper:
    $type: boolean
    $default: no
    $help: For now it only can be used in Btrfs filesystems
  # TODO: How to export the values from the locale formula?
  locale:
    $type: select
    # Output from 'localectl list-locales'
    $values:
      - C.utf8
      - aa_DJ
      - aa_DJ.utf8
      - aa_ER
      - aa_ER@saaho
      - aa_ET
      - af_ZA
      - af_ZA.utf8
      - agr_PE
      - ak_GH
      - am_ET
      - an_ES
      - an_ES.utf8
      - anp_IN
      - ar_AE
      - ar_AE.utf8
      - ar_BH
      - ar_BH.utf8
      - ar_DZ
      - ar_DZ.utf8
      - ar_EG
      - ar_EG.utf8
      - ar_IN
      - ar_IQ
      - ar_IQ.utf8
      - ar_JO
      - ar_JO.utf8
      - ar_KW
      - ar_KW.utf8
      - ar_LB
      - ar_LB.utf8
      - ar_LY
      - ar_LY.utf8
      - ar_MA
      - ar_MA.utf8
      - ar_OM
      - ar_OM.utf8
      - ar_QA
      - ar_QA.utf8
      - ar_SA
      - ar_SA.utf8
      - ar_SD
      - ar_SD.utf8
      - ar_SS
      - ar_SY
      - ar_SY.utf8
      - ar_TN
      - ar_TN.utf8
      - ar_YE
      - ar_YE.utf8
      - as_IN
      - ast_ES
      - ast_ES.utf8
      - ayc_PE
      - az_AZ
      - az_IR
      - be_BY
      - be_BY.utf8
      - be_BY@latin
      - bem_ZM
      - ber_DZ
      - ber_MA
      - bg_BG
      - bg_BG.utf8
      - bhb_IN.utf8
      - bho_IN
      - bi_VU
      - bn_BD
      - bn_IN
      - bo_CN
      - bo_IN
      - br_FR
      - br_FR.utf8
      - br_FR@euro
      - brx_IN
      - bs_BA
      - bs_BA.utf8
      - byn_ER
      - ca_AD
      - ca_AD.utf8
      - ca_ES
      - ca_ES.utf8
      - ca_ES@euro
      - ca_FR
      - ca_FR.utf8
      - ca_IT
      - ca_IT.utf8
      - ce_RU
      - chr_US
      - cmn_TW
      - crh_UA
      - cs_CZ
      - cs_CZ.utf8
      - csb_PL
      - cv_RU
      - cy_GB
      - cy_GB.utf8
      - da_DK
      - da_DK.utf8
      - de_AT
      - de_AT.utf8
      - de_AT@euro
      - de_BE
      - de_BE.utf8
      - de_BE@euro
      - de_CH
      - de_CH.utf8
      - de_DE
      - de_DE.utf8
      - de_DE@euro
      - de_IT
      - de_IT.utf8
      - de_LI.utf8
      - de_LU
      - de_LU.utf8
      - de_LU@euro
      - doi_IN
      - dv_MV
      - dz_BT
      - el_CY
      - el_CY.utf8
      - el_GR
      - el_GR.utf8
      - el_GR@euro
      - en_AG
      - en_AU
      - en_AU.utf8
      - en_BW
      - en_BW.utf8
      - en_CA
      - en_CA.utf8
      - en_DK
      - en_DK.utf8
      - en_GB
      - en_GB.iso885915
      - en_GB.utf8
      - en_HK
      - en_HK.utf8
      - en_IE
      - en_IE.utf8
      - en_IE@euro
      - en_IL
      - en_IN
      - en_NG
      - en_NZ
      - en_NZ.utf8
      - en_PH
      - en_PH.utf8
      - en_SG
      - en_SG.utf8
      - en_US
      - en_US.iso885915
      - en_US.utf8
      - en_ZA
      - en_ZA.utf8
      - en_ZM
      - en_ZW
      - en_ZW.utf8
      - eo
      - es_AR
      - es_AR.utf8
      - es_BO
      - es_BO.utf8
      - es_CL
      - es_CL.utf8
      - es_CO
      - es_CO.utf8
      - es_CR
      - es_CR.utf8
      - es_CU
      - es_DO
      - es_DO.utf8
      - es_EC
      - es_EC.utf8
      - es_ES
      - es_ES.utf8
      - es_ES@euro
      - es_GT
      - es_GT.utf8
      - es_HN
      - es_HN.utf8
      - es_MX
      - es_MX.utf8
      - es_NI
      - es_NI.utf8
      - es_PA
      - es_PA.utf8
      - es_PE
      - es_PE.utf8
      - es_PR
      - es_PR.utf8
      - es_PY
      - es_PY.utf8
      - es_SV
      - es_SV.utf8
      - es_US
      - es_US.utf8
      - es_UY
      - es_UY.utf8
      - es_VE
      - es_VE.utf8
      - et_EE
      - et_EE.iso885915
      - et_EE.utf8
      - eu_ES
      - eu_ES.utf8
      - eu_ES@euro
      - fa_IR
      - ff_SN
      - fi_FI
      - fi_FI.utf8
      - fi_FI@euro
      - fil_PH
      - fo_FO
      - fo_FO.utf8
      - fr_BE
      - fr_BE.utf8
      - fr_BE@euro
      - fr_CA
      - fr_CA.utf8
      - fr_CH
      - fr_CH.utf8
      - fr_FR
      - fr_FR.utf8
      - fr_FR@euro
      - fr_LU
      - fr_LU.utf8
      - fr_LU@euro
      - fur_IT
      - fy_DE
      - fy_NL
      - ga_IE
      - ga_IE.utf8
      - ga_IE@euro
      - gd_GB
      - gd_GB.utf8
      - gez_ER
      - gez_ER@abegede
      - gez_ET
      - gez_ET@abegede
      - gl_ES
      - gl_ES.utf8
      - gl_ES@euro
      - gu_IN
      - gv_GB
      - gv_GB.utf8
      - ha_NG
      - hak_TW
      - he_IL
      - he_IL.utf8
      - hi_IN
      - hif_FJ
      - hne_IN
      - hr_HR
      - hr_HR.utf8
      - hsb_DE
      - hsb_DE.utf8
      - ht_HT
      - hu_HU
      - hu_HU.utf8
      - hy_AM
      - hy_AM.armscii8
      - ia_FR
      - id_ID
      - id_ID.utf8
      - ig_NG
      - ik_CA
      - is_IS
      - is_IS.utf8
      - it_CH
      - it_CH.utf8
      - it_IT
      - it_IT.utf8
      - it_IT@euro
      - iu_CA
      - ja_JP.eucjp
      - ja_JP.shiftjisx0213
      - ja_JP.sjis
      - ja_JP.utf8
      - ka_GE
      - ka_GE.utf8
      - kk_KZ
      - kk_KZ.utf8
      - kl_GL
      - kl_GL.utf8
      - km_KH
      - kn_IN
      - ko_KR.euckr
      - ko_KR.utf8
      - kok_IN
      - ks_IN
      - ks_IN@devanagari
      - ku_TR
      - ku_TR.utf8
      - kw_GB
      - kw_GB.utf8
      - ky_KG
      - lb_LU
      - lg_UG
      - lg_UG.utf8
      - li_BE
      - li_NL
      - lij_IT
      - ln_CD
      - lo_LA
      - lt_LT
      - lt_LT.utf8
      - lv_LV
      - lv_LV.utf8
      - lzh_TW
      - mag_IN
      - mai_IN
      - mai_NP
      - mg_MG
      - mg_MG.utf8
      - mhr_RU
      - mi_NZ
      - mi_NZ.utf8
      - mk_MK
      - mk_MK.utf8
      - ml_IN
      - mn_MN
      - mni_IN
      - mr_IN
      - ms_MY
      - ms_MY.utf8
      - mt_MT
      - mt_MT.utf8
      - my_MM
      - nan_TW
      - nan_TW@latin
      - nb_NO
      - nb_NO.utf8
      - nds_DE
      - nds_NL
      - ne_NP
      - nhn_MX
      - niu_NU
      - niu_NZ
      - nl_AW
      - nl_BE
      - nl_BE.utf8
      - nl_BE@euro
      - nl_NL
      - nl_NL.utf8
      - nl_NL@euro
      - nn_NO
      - nn_NO.utf8
      - no_NO
      - no_NO.utf8
      - nr_ZA
      - nso_ZA
      - oc_FR
      - oc_FR.utf8
      - om_ET
      - om_KE
      - om_KE.utf8
      - or_IN
      - os_RU
      - pa_IN
      - pa_PK
      - pap_AW
      - pap_CW
      - pl_PL
      - pl_PL.utf8
      - ps_AF
      - pt_BR
      - pt_BR.utf8
      - pt_PT
      - pt_PT.utf8
      - pt_PT@euro
      - quz_PE
      - raj_IN
      - ro_RO
      - ro_RO.utf8
      - ru_RU
      - ru_RU.koi8r
      - ru_RU.utf8
      - ru_UA
      - ru_UA.utf8
      - rw_RW
      - sa_IN
      - sat_IN
      - sc_IT
      - sd_IN
      - sd_IN@devanagari
      - se_NO
      - sgs_LT
      - shs_CA
      - si_LK
      - sid_ET
      - sk_SK
      - sk_SK.utf8
      - sl_SI
      - sl_SI.utf8
      - sm_WS
      - so_DJ
      - so_DJ.utf8
      - so_ET
      - so_KE
      - so_KE.utf8
      - so_SO
      - so_SO.utf8
      - sq_AL
      - sq_AL.utf8
      - sq_MK
      - sr_ME
      - sr_RS
      - sr_RS@latin
      - ss_ZA
      - st_ZA
      - st_ZA.utf8
      - sv_FI
      - sv_FI.utf8
      - sv_FI@euro
      - sv_SE
      - sv_SE.utf8
      - sw_KE
      - sw_TZ
      - szl_PL
      - ta_IN
      - ta_LK
      - tcy_IN.utf8
      - te_IN
      - tg_TJ
      - tg_TJ.utf8
      - th_TH
      - th_TH.utf8
      - the_NP
      - ti_ER
      - ti_ET
      - tig_ER
      - tk_TM
      - tl_PH
      - tl_PH.utf8
      - tn_ZA
      - to_TO
      - tpi_PG
      - tr_CY
      - tr_CY.utf8
      - tr_TR
      - tr_TR.utf8
      - ts_ZA
      - tt_RU
      - tt_RU@iqtelif
      - ug_CN
      - uk_UA
      - uk_UA.utf8
      - unm_US
      - ur_IN
      - ur_PK
      - uz_UZ
      - uz_UZ.utf8
      - uz_UZ@cyrillic
      - ve_ZA
      - vi_VN
      - wa_BE
      - wa_BE.utf8
      - wa_BE@euro
      - wae_CH
      - wal_ET
      - wo_SN
      - xh_ZA
      - xh_ZA.utf8
      - yi_US
      - yi_US.utf8
      - yo_NG
      - yue_HK
      - zh_CN
      - zh_CN.gb18030
      - zh_CN.gbk
      - zh_CN.utf8
      - zh_HK
      - zh_HK.utf8
      - zh_SG
      - zh_SG.gbk
      - zh_SG.utf8
      - zh_TW
      - zh_TW.euctw
      - zh_TW.utf8
      - zu_ZA
      - zu_ZA.utf8
    $default: en_US.utf8
    $help: System locale configuration for systemd
  keymap:
    $type: select
    # Output from 'localectl list-keymaps'
    $values:
      - ANSI-dvorak
      - Pl02
      - al
      - al-plisi
      - amiga-de
      - amiga-us
      - applkey
      - at
      - at-mac
      - at-nodeadkeys
      - at-sundeadkeys
      - atari-de
      - atari-se
      - atari-uk-falcon
      - atari-us
      - az
      - azerty
      - ba
      - ba-alternatequotes
      - ba-unicode
      - ba-unicodeus
      - ba-us
      - backspace
      - bashkir
      - be
      - be-iso-alternate
      - be-latin1
      - be-nodeadkeys
      - be-oss
      - be-oss_latin9
      - be-oss_sundeadkeys
      - be-sundeadkeys
      - be-wang
      - bg-cp1251
      - bg-cp855
      - bg_bds-cp1251
      - bg_bds-utf8
      - bg_pho-cp1251
      - bg_pho-utf8
      - br
      - br-abnt
      - br-abnt-alt
      - br-abnt2
      - br-abnt2-old
      - br-dvorak
      - br-latin1-abnt2
      - br-latin1-us
      - br-nativo
      - br-nativo-epo
      - br-nativo-us
      - br-nodeadkeys
      - br-thinkpad
      - by
      - by-cp1251
      - by-latin
      - bywin-cp1251
      - ca
      - ca-eng
      - ca-fr-dvorak
      - ca-fr-legacy
      - ca-multi
      - ca-multix
      - carpalx
      - carpalx-full
      - cf
      - ch
      - ch-de_mac
      - ch-de_nodeadkeys
      - ch-de_sundeadkeys
      - ch-fr
      - ch-fr_mac
      - ch-fr_nodeadkeys
      - ch-fr_sundeadkeys
      - ch-legacy
      - cm
      - cm-azerty
      - cm-dvorak
      - cm-french
      - cm-mmuock
      - cm-qwerty
      - cn
      - cn-latin1
      - croat
      - ctrl
      - cz
      - cz-bksl
      - cz-cp1250
      - cz-dvorak-ucw
      - cz-lat2
      - cz-lat2-prog
      - cz-lat2-us
      - cz-qwerty
      - cz-qwerty_bksl
      - cz-rus
      - cz-us-qwertz
      - de
      - de-T3
      - de-deadacute
      - de-deadgraveacute
      - de-deadtilde
      - de-dsb
      - de-dsb_qwertz
      - de-dvorak
      - de-latin1
      - de-latin1-nodeadkeys
      - de-mac
      - de-mac_nodeadkeys
      - de-mobii
      - de-neo
      - de-nodeadkeys
      - de-qwerty
      - de-ro
      - de-ro_nodeadkeys
      - de-sundeadkeys
      - de-tr
      - de_CH-latin1
      - de_alt_UTF-8
      - defkeymap
      - defkeymap_V1.0
      - dk
      - dk-dvorak
      - dk-latin1
      - dk-mac
      - dk-mac_nodeadkeys
      - dk-nodeadkeys
      - dk-winkeys
      - dvorak
      - dvorak-ca-fr
      - dvorak-es
      - dvorak-fr
      - dvorak-l
      - dvorak-la
      - dvorak-programmer
      - dvorak-r
      - dvorak-ru
      - dvorak-sv-a1
      - dvorak-sv-a5
      - dvorak-uk
      - dz
      - ee
      - ee-dvorak
      - ee-nodeadkeys
      - ee-us
      - emacs
      - emacs2
      - en-latin9
      - epo
      - epo-legacy
      - es
      - es-ast
      - es-cat
      - es-cp850
      - es-deadtilde
      - es-dvorak
      - es-mac
      - es-nodeadkeys
      - es-olpc
      - es-sundeadkeys
      - es-winkeys
      - et
      - et-nodeadkeys
      - euro
      - euro1
      - euro2
      - fi
      - fi-classic
      - fi-kotoistus
      - fi-mac
      - fi-nodeadkeys
      - fi-smi
      - fi-winkeys
      - fo
      - fo-nodeadkeys
      - fr
      - fr-azerty
      - fr-bepo
      - fr-bepo-latin9
      - fr-bepo_latin9
      - fr-bre
      - fr-dvorak
      - fr-latin1
      - fr-latin9
      - fr-latin9_nodeadkeys
      - fr-latin9_sundeadkeys
      - fr-mac
      - fr-nodeadkeys
      - fr-oci
      - fr-oss
      - fr-oss_latin9
      - fr-oss_nodeadkeys
      - fr-oss_sundeadkeys
      - fr-pc
      - fr-sundeadkeys
      - fr_CH
      - fr_CH-latin1
      - gb
      - gb-colemak
      - gb-dvorak
      - gb-dvorakukp
      - gb-extd
      - gb-intl
      - gb-mac
      - gb-mac_intl
      - ge
      - ge-ergonomic
      - ge-mess
      - ge-ru
      - gh
      - gh-akan
      - gh-avn
      - gh-ewe
      - gh-fula
      - gh-ga
      - gh-generic
      - gh-gillbt
      - gh-hausa
      - gr
      - gr-pc
      - hr
      - hr-alternatequotes
      - hr-unicode
      - hr-unicodeus
      - hr-us
      - hu
      - hu-101_qwerty_comma_dead
      - hu-101_qwerty_comma_nodead
      - hu-101_qwerty_dot_dead
      - hu-101_qwerty_dot_nodead
      - hu-101_qwertz_comma_dead
      - hu-101_qwertz_comma_nodead
      - hu-101_qwertz_dot_dead
      - hu-101_qwertz_dot_nodead
      - hu-102_qwerty_comma_dead
      - hu-102_qwerty_comma_nodead
      - hu-102_qwerty_dot_dead
      - hu-102_qwerty_dot_nodead
      - hu-102_qwertz_comma_dead
      - hu-102_qwertz_comma_nodead
      - hu-102_qwertz_dot_dead
      - hu-102_qwertz_dot_nodead
      - hu-nodeadkeys
      - hu-qwerty
      - hu-standard
      - hu101
      - ie
      - ie-CloGaelach
      - ie-UnicodeExpert
      - ie-ogam_is434
      - il
      - il-heb
      - il-phonetic
      - in-eng
      - iq-ku
      - iq-ku_alt
      - iq-ku_ara
      - iq-ku_f
      - ir-ku
      - ir-ku_alt
      - ir-ku_ara
      - ir-ku_f
      - is
      - is-Sundeadkeys
      - is-dvorak
      - is-latin1
      - is-latin1-us
      - is-mac
      - is-mac_legacy
      - is-nodeadkeys
      - it
      - it-geo
      - it-ibm
      - it-intl
      - it-mac
      - it-nodeadkeys
      - it-scn
      - it-us
      - it-winkeys
      - it2
      - jp
      - jp-OADG109A
      - jp-dvorak
      - jp-kana86
      - jp106
      - kazakh
      - ke
      - ke-kik
      - keypad
      - kr
      - kr-kr104
      - ky_alt_sh-UTF-8
      - kyrgyz
      - la-latin1
      - latam
      - latam-deadtilde
      - latam-dvorak
      - latam-nodeadkeys
      - latam-sundeadkeys
      - lk-us
      - lt
      - lt-ibm
      - lt-lekp
      - lt-lekpa
      - lt-std
      - lt-us
      - lt.baltic
      - lt.l4
      - lt.std
      - lv
      - lv-adapted
      - lv-apostrophe
      - lv-ergonomic
      - lv-fkey
      - lv-modern
      - lv-tilde
      - ma-french
      - mac-be
      - mac-de-latin1
      - mac-de-latin1-nodeadkeys
      - mac-de_CH
      - mac-dk-latin1
      - mac-dvorak
      - mac-es
      - mac-euro
      - mac-euro2
      - mac-fi-latin1
      - mac-fr
      - mac-fr_CH-latin1
      - mac-it
      - mac-pl
      - mac-pt-latin1
      - mac-se
      - mac-template
      - mac-uk
      - mac-us
      - md
      - md-gag
      - me
      - me-latinalternatequotes
      - me-latinunicode
      - me-latinunicodeyz
      - me-latinyz
      - mk
      - mk-cp1251
      - mk-utf
      - mk0
      - ml
      - ml-fr-oss
      - ml-us-intl
      - ml-us-mac
      - mt
      - mt-us
      - ng
      - ng-hausa
      - ng-igbo
      - ng-yoruba
      - nl
      - nl-mac
      - nl-std
      - nl-sundeadkeys
      - nl2
      - "no"
      - no-colemak
      - no-dvorak
      - no-latin1
      - no-mac
      - no-mac_nodeadkeys
      - no-nodeadkeys
      - no-smi
      - no-smi_nodeadkeys
      - no-winkeys
      - pc110
      - ph
      - ph-capewell-dvorak
      - ph-capewell-qwerf2k6
      - ph-colemak
      - ph-dvorak
      - pl
      - pl-csb
      - pl-dvorak
      - pl-dvorak_altquotes
      - pl-dvorak_quotes
      - pl-dvp
      - pl-legacy
      - pl-qwertz
      - pl-szl
      - pl1
      - pl2
      - pl3
      - pl4
      - pt
      - pt-latin1
      - pt-latin9
      - pt-mac
      - pt-mac_nodeadkeys
      - pt-mac_sundeadkeys
      - pt-nativo
      - pt-nativo-epo
      - pt-nativo-us
      - pt-nodeadkeys
      - pt-sundeadkeys
      - ro
      - ro-cedilla
      - ro-latin2
      - ro-std
      - ro-std_cedilla
      - ro-winkeys
      - ro_std
      - ro_win
      - rs-latin
      - rs-latinalternatequotes
      - rs-latinunicode
      - rs-latinunicodeyz
      - rs-latinyz
      - ru
      - ru-cp1251
      - ru-cv_latin
      - ru-ms
      - ru-yawerty
      - ru1
      - ru1_win-utf
      - ru2
      - ru3
      - ru4
      - ru_win
      - ruwin_alt-CP1251
      - ruwin_alt-KOI8-R
      - ruwin_alt-UTF-8
      - ruwin_alt_sh-UTF-8
      - ruwin_cplk-CP1251
      - ruwin_cplk-KOI8-R
      - ruwin_cplk-UTF-8
      - ruwin_ct_sh-CP1251
      - ruwin_ct_sh-KOI8-R
      - ruwin_ct_sh-UTF-8
      - ruwin_ctrl-CP1251
      - ruwin_ctrl-KOI8-R
      - ruwin_ctrl-UTF-8
      - se
      - se-dvorak
      - se-fi-ir209
      - se-fi-lat6
      - se-ir209
      - se-lat6
      - se-latin1
      - se-mac
      - se-nodeadkeys
      - se-smi
      - se-svdvorak
      - se-us_dvorak
      - sg
      - sg-latin1
      - sg-latin1-lk450
      - si
      - si-alternatequotes
      - si-us
      - sk
      - sk-bksl
      - sk-prog-qwerty
      - sk-prog-qwertz
      - sk-qwerty
      - sk-qwerty_bksl
      - sk-qwertz
      - slovene
      - sr-cy
      - sun-pl
      - sun-pl-altgraph
      - sundvorak
      - sunkeymap
      - sunt4-es
      - sunt4-fi-latin1
      - sunt4-no-latin1
      - sunt5-cz-us
      - sunt5-de-latin1
      - sunt5-es
      - sunt5-fi-latin1
      - sunt5-fr-latin1
      - sunt5-ru
      - sunt5-uk
      - sunt5-us-cz
      - sunt6-uk
      - sv-latin1
      - sy-ku
      - sy-ku_alt
      - sy-ku_f
      - tj_alt-UTF8
      - tm
      - tm-alt
      - tr
      - tr-alt
      - tr-crh
      - tr-crh_alt
      - tr-crh_f
      - tr-f
      - tr-intl
      - tr-ku
      - tr-ku_alt
      - tr-ku_f
      - tr-sundeadkeys
      - tr_f-latin5
      - tr_q-latin5
      - tralt
      - trf
      - trq
      - ttwin_alt-UTF-8
      - ttwin_cplk-UTF-8
      - ttwin_ct_sh-UTF-8
      - ttwin_ctrl-UTF-8
      - tw
      - tw-indigenous
      - tw-saisiyat
      - ua
      - ua-cp1251
      - ua-utf
      - ua-utf-ws
      - ua-ws
      - uk
      - unicode
      - us
      - us-acentos
      - us-acentos-old
      - us-alt-intl
      - us-altgr-intl
      - us-colemak
      - us-dvorak
      - us-dvorak-alt-intl
      - us-dvorak-classic
      - us-dvorak-intl
      - us-dvorak-l
      - us-dvorak-r
      - us-dvp
      - us-euro
      - us-hbs
      - us-intl
      - us-mac
      - us-olpc2
      - us-workman
      - us-workman-intl
      - uz-latin
      - wangbe
      - wangbe2
      - windowkeys
    $default: us
    $help: System keyboard configuration for systemd
  timezone:
    $type: select
    # Output from 'timedatectl list-timezones'
    $values:
      - Africa/Abidjan
      - Africa/Accra
      - Africa/Algiers
      - Africa/Bissau
      - Africa/Cairo
      - Africa/Casablanca
      - Africa/Ceuta
      - Africa/El_Aaiun
      - Africa/Johannesburg
      - Africa/Juba
      - Africa/Khartoum
      - Africa/Lagos
      - Africa/Maputo
      - Africa/Monrovia
      - Africa/Nairobi
      - Africa/Ndjamena
      - Africa/Sao_Tome
      - Africa/Tripoli
      - Africa/Tunis
      - Africa/Windhoek
      - America/Adak
      - America/Anchorage
      - America/Araguaina
      - America/Argentina/Buenos_Aires
      - America/Argentina/Catamarca
      - America/Argentina/Cordoba
      - America/Argentina/Jujuy
      - America/Argentina/La_Rioja
      - America/Argentina/Mendoza
      - America/Argentina/Rio_Gallegos
      - America/Argentina/Salta
      - America/Argentina/San_Juan
      - America/Argentina/San_Luis
      - America/Argentina/Tucuman
      - America/Argentina/Ushuaia
      - America/Asuncion
      - America/Atikokan
      - America/Bahia
      - America/Bahia_Banderas
      - America/Barbados
      - America/Belem
      - America/Belize
      - America/Blanc-Sablon
      - America/Boa_Vista
      - America/Bogota
      - America/Boise
      - America/Cambridge_Bay
      - America/Campo_Grande
      - America/Cancun
      - America/Caracas
      - America/Cayenne
      - America/Chicago
      - America/Chihuahua
      - America/Costa_Rica
      - America/Creston
      - America/Cuiaba
      - America/Curacao
      - America/Danmarkshavn
      - America/Dawson
      - America/Dawson_Creek
      - America/Denver
      - America/Detroit
      - America/Edmonton
      - America/Eirunepe
      - America/El_Salvador
      - America/Fort_Nelson
      - America/Fortaleza
      - America/Glace_Bay
      - America/Godthab
      - America/Goose_Bay
      - America/Grand_Turk
      - America/Guatemala
      - America/Guayaquil
      - America/Guyana
      - America/Halifax
      - America/Havana
      - America/Hermosillo
      - America/Indiana/Indianapolis
      - America/Indiana/Knox
      - America/Indiana/Marengo
      - America/Indiana/Petersburg
      - America/Indiana/Tell_City
      - America/Indiana/Vevay
      - America/Indiana/Vincennes
      - America/Indiana/Winamac
      - America/Inuvik
      - America/Iqaluit
      - America/Jamaica
      - America/Juneau
      - America/Kentucky/Louisville
      - America/Kentucky/Monticello
      - America/La_Paz
      - America/Lima
      - America/Los_Angeles
      - America/Maceio
      - America/Managua
      - America/Manaus
      - America/Martinique
      - America/Matamoros
      - America/Mazatlan
      - America/Menominee
      - America/Merida
      - America/Metlakatla
      - America/Mexico_City
      - America/Miquelon
      - America/Moncton
      - America/Monterrey
      - America/Montevideo
      - America/Nassau
      - America/New_York
      - America/Nipigon
      - America/Nome
      - America/Noronha
      - America/North_Dakota/Beulah
      - America/North_Dakota/Center
      - America/North_Dakota/New_Salem
      - America/Ojinaga
      - America/Panama
      - America/Pangnirtung
      - America/Paramaribo
      - America/Phoenix
      - America/Port-au-Prince
      - America/Port_of_Spain
      - America/Porto_Velho
      - America/Puerto_Rico
      - America/Punta_Arenas
      - America/Rainy_River
      - America/Rankin_Inlet
      - America/Recife
      - America/Regina
      - America/Resolute
      - America/Rio_Branco
      - America/Santarem
      - America/Santiago
      - America/Santo_Domingo
      - America/Sao_Paulo
      - America/Scoresbysund
      - America/Sitka
      - America/St_Johns
      - America/Swift_Current
      - America/Tegucigalpa
      - America/Thule
      - America/Thunder_Bay
      - America/Tijuana
      - America/Toronto
      - America/Vancouver
      - America/Whitehorse
      - America/Winnipeg
      - America/Yakutat
      - America/Yellowknife
      - Antarctica/Casey
      - Antarctica/Davis
      - Antarctica/DumontDUrville
      - Antarctica/Macquarie
      - Antarctica/Mawson
      - Antarctica/Palmer
      - Antarctica/Rothera
      - Antarctica/Syowa
      - Antarctica/Troll
      - Antarctica/Vostok
      - Asia/Almaty
      - Asia/Amman
      - Asia/Anadyr
      - Asia/Aqtau
      - Asia/Aqtobe
      - Asia/Ashgabat
      - Asia/Atyrau
      - Asia/Baghdad
      - Asia/Baku
      - Asia/Bangkok
      - Asia/Barnaul
      - Asia/Beirut
      - Asia/Bishkek
      - Asia/Brunei
      - Asia/Chita
      - Asia/Choibalsan
      - Asia/Colombo
      - Asia/Damascus
      - Asia/Dhaka
      - Asia/Dili
      - Asia/Dubai
      - Asia/Dushanbe
      - Asia/Famagusta
      - Asia/Gaza
      - Asia/Hebron
      - Asia/Ho_Chi_Minh
      - Asia/Hong_Kong
      - Asia/Hovd
      - Asia/Irkutsk
      - Asia/Jakarta
      - Asia/Jayapura
      - Asia/Jerusalem
      - Asia/Kabul
      - Asia/Kamchatka
      - Asia/Karachi
      - Asia/Kathmandu
      - Asia/Khandyga
      - Asia/Kolkata
      - Asia/Krasnoyarsk
      - Asia/Kuala_Lumpur
      - Asia/Kuching
      - Asia/Macau
      - Asia/Magadan
      - Asia/Makassar
      - Asia/Manila
      - Asia/Nicosia
      - Asia/Novokuznetsk
      - Asia/Novosibirsk
      - Asia/Omsk
      - Asia/Oral
      - Asia/Pontianak
      - Asia/Pyongyang
      - Asia/Qatar
      - Asia/Qostanay
      - Asia/Qyzylorda
      - Asia/Riyadh
      - Asia/Sakhalin
      - Asia/Samarkand
      - Asia/Seoul
      - Asia/Shanghai
      - Asia/Singapore
      - Asia/Srednekolymsk
      - Asia/Taipei
      - Asia/Tashkent
      - Asia/Tbilisi
      - Asia/Tehran
      - Asia/Thimphu
      - Asia/Tokyo
      - Asia/Tomsk
      - Asia/Ulaanbaatar
      - Asia/Urumqi
      - Asia/Ust-Nera
      - Asia/Vladivostok
      - Asia/Yakutsk
      - Asia/Yangon
      - Asia/Yekaterinburg
      - Asia/Yerevan
      - Atlantic/Azores
      - Atlantic/Bermuda
      - Atlantic/Canary
      - Atlantic/Cape_Verde
      - Atlantic/Faroe
      - Atlantic/Madeira
      - Atlantic/Reykjavik
      - Atlantic/South_Georgia
      - Atlantic/Stanley
      - Australia/Adelaide
      - Australia/Brisbane
      - Australia/Broken_Hill
      - Australia/Currie
      - Australia/Darwin
      - Australia/Eucla
      - Australia/Hobart
      - Australia/Lindeman
      - Australia/Lord_Howe
      - Australia/Melbourne
      - Australia/Perth
      - Australia/Sydney
      - Europe/Amsterdam
      - Europe/Andorra
      - Europe/Astrakhan
      - Europe/Athens
      - Europe/Belgrade
      - Europe/Berlin
      - Europe/Brussels
      - Europe/Bucharest
      - Europe/Budapest
      - Europe/Chisinau
      - Europe/Copenhagen
      - Europe/Dublin
      - Europe/Gibraltar
      - Europe/Helsinki
      - Europe/Istanbul
      - Europe/Kaliningrad
      - Europe/Kiev
      - Europe/Kirov
      - Europe/Lisbon
      - Europe/London
      - Europe/Luxembourg
      - Europe/Madrid
      - Europe/Malta
      - Europe/Minsk
      - Europe/Monaco
      - Europe/Moscow
      - Europe/Oslo
      - Europe/Paris
      - Europe/Prague
      - Europe/Riga
      - Europe/Rome
      - Europe/Samara
      - Europe/Saratov
      - Europe/Simferopol
      - Europe/Sofia
      - Europe/Stockholm
      - Europe/Tallinn
      - Europe/Tirane
      - Europe/Ulyanovsk
      - Europe/Uzhgorod
      - Europe/Vienna
      - Europe/Vilnius
      - Europe/Volgograd
      - Europe/Warsaw
      - Europe/Zaporozhye
      - Europe/Zurich
      - Indian/Chagos
      - Indian/Christmas
      - Indian/Cocos
      - Indian/Kerguelen
      - Indian/Mahe
      - Indian/Maldives
      - Indian/Mauritius
      - Indian/Reunion
      - Pacific/Apia
      - Pacific/Auckland
      - Pacific/Bougainville
      - Pacific/Chatham
      - Pacific/Chuuk
      - Pacific/Easter
      - Pacific/Efate
      - Pacific/Enderbury
      - Pacific/Fakaofo
      - Pacific/Fiji
      - Pacific/Funafuti
      - Pacific/Galapagos
      - Pacific/Gambier
      - Pacific/Guadalcanal
      - Pacific/Guam
      - Pacific/Honolulu
      - Pacific/Kiritimati
      - Pacific/Kosrae
      - Pacific/Kwajalein
      - Pacific/Majuro
      - Pacific/Marquesas
      - Pacific/Nauru
      - Pacific/Niue
      - Pacific/Norfolk
      - Pacific/Noumea
      - Pacific/Pago_Pago
      - Pacific/Palau
      - Pacific/Pitcairn
      - Pacific/Pohnpei
      - Pacific/Port_Moresby
      - Pacific/Rarotonga
      - Pacific/Tahiti
      - Pacific/Tarawa
      - Pacific/Tongatapu
      - Pacific/Wake
      - Pacific/Wallis
      - UTC
    $default: UTC
    $help: System timezone configuration for systemd
  hostname:
    $type: text
    $optional: yes
    $help: Leave it empty when DHCP provides a hostname
  machine_id:
    $type: text
    $optional: yes
    $help: If empty, systemd will generate one
  target:
    $type: text
    $optional: yes
    $default: multi-user.target
    $ifEmpty: multi-user.target
    $help: Valid systemd target unit
07070100000010000081A40000427000000032000000015F4E04F8000020A6000000000000000000000000000000000000004400000000yomi-0.0.1+git.1598948600.9a9eab0/metadata/02-form-yomi-storage.yml# Uyuni Form for the Yomi pillar data - Storage and filesystem
#
# Find mode pillar examples in /usr/share/yomi/pillar

partitions:
  $type: group
  $help: Partiton (Storage) Subsection for the Yomi Formula
  config:
    $type: group
    $help: Configuration options for the partitioner
    label:
      $type: select
      $values:
        # - aix
        # - amiga
        # - bsd
        # - dvh
        - gpt
        # - mac
        - msdos
        # - pc98
        # - sun
        # - loop
      $default: gpt
      $help: Default type of partition table for the device
    initial_gap:
      $type: text
      $optional: yes
      $default: 0
      $help: Initial gap (empty space) leaved before the first partition. Valid units are s, B, kB, MB, GB, TB, compact, cyl, chs, %, kiB, MiB, GiB, TiB
  devices:
    $type: edit-group
    $minItems: 1
    $itemName: Device ${i}
    $help: List of (physical or logical) devices
    $prototype:
      $type: group
      $key:
        $name: Device
        $type: text
        $placeholder: /dev/sda
        $help: Device name. Names like /dev/disk/by-id/... or /dev/disk/by-label/... can be used
      label:
        $type: select
        $values:
          # - aix
          # - amiga
          # - bsd
          # - dvh
          - gpt
          # - mac
          - msdos
          # - pc98
          # - sun
          # - loop
        $default: gpt
        $help: Type of partition table for the device
      initial_gap:
        $type: text
        $optional: yes
        $default: 1MB
        $help: Initial gap (empty space) leaved before the first partition. Valid units are s, B, kB, MB, GB, TB, compact, cyl, chs, %, kiB, MiB, GiB, TiB
      partitions:
        $type: edit-group
        $minItems: 0
        $itemName: Partition ${i}
        $help: List of partitions for the device
        $prototype:
          number:
            $name: Partition Number
            $type: number
            $optional: yes
            # $default: ${i}
            $help: Will be appended to the device name (E.g. /dev/sda1 for devide /dev/sda and partition number 1)
          id:
            $name: Partition Name
            $type: text
            $optional: yes
            $placeholder: /dev/sda1
            $help: "Full name of the partition. For example, valid ids can be /dev/sda1, /dev/md0p1, etc. Is optional, as the name can be deduced from 'Partition Number'"
          size:
            $name: Partition Size
            $type: text
            $placeholder: "Parted units or 'rest': 500MB"
            $help: "Valid units are s, B, kB, MB, GB, TB, compact, cyl, chs, %, kiB, MiB, GiB, TiB. Use 'rest' to indicate the rest of the free space"
          type:
            $name: Partition Type
            $type: select
            $values:
              - swap
              - linux
              - boot
              - efi
              - lvm
              - raid
            $default: linux
            $help: Indicate the expected use of the partition

lvm:
  $type: edit-group
  $minItems: 0
  $itemName: Volume Group ${i}
  $help: LVM (Storage) Subsection for the Yomi Formula
  $prototype:
    $type: group
    $key:
      $name: Volume Group Name
      $type: text
      $help: Name of the logical volume
    devices:
      $type: edit-group
      $minItems: 1
      $itemName: Device or Partition ${i}
      $help: List of devices or partitions that belong to the volume
      $prototype:
        name:
          $name: Device or Partition
          $type: text
          $placeholder: /dev/sda1
          $help: Device or Partition with type LVM
        bootloaderareasize:
          $name: Boot Loader Area Size
          $type: text
          $optional: yes
          $help: "Directly passed to 'pvcreate'"
        dataaligment:
          $name: Data Aligment
          $type: text
          $optional: yes
          $help: "Directly passed to 'pvcreate'"
        dataalignmentoffset:
          $name: Data Aligment Offset
          $type: text
          $optional: yes
          $help: "Directly passed to 'pvcreate'"
    volumes:
      $type: edit-group
      $minItems: 1
      $itemName: Logical Volume ${i}
      $help: List of logical volumes
      $prototype:
        name:
          $name: Logical Volume Name
          $type: text
          $placeholder: root
          $help: Name of the logical volume
        extents:
          $type: text
          $optional: yes
          $placeholder: 100%FREE
          $help: "Directly passed to 'lvcreate'"
        size:
          $type: text
          $optional: yes
          $placeholder: 1024M
          $help: "Directly passed to 'lvcreate'"
        stripes:
          $type: number
          $optional: yes
          $help: "Directly passed to 'lvcreate'"
        stripesize:
          $name: Stripe Size
          $type: number
          $optional: yes
          $help: "Directly passed to 'lvcreate'"
        # There are more options that we can implement for LVM
    clustered:
      $type: select
      $optional: yes
      $values:
        - "y"
        - "n"
      $default: "n"
      $help: "Directly passed to 'vgcreate'"
    maxlogicalvolumes:
      $name: Max Logical Volumes
      $type: number
      $optional: yes
      $help: "Directly passed to 'vgcreate'"
    maxphysicalvolumes:
      $name: Max Physical Volumes
      $type: number
      $optional: yes
      $help: "Directly passed to 'vgcreate'"
    physicalextentsize:
      $name: Physical Extent Size
      $type: text
      $optional: yes
      $help: "Directly passed to 'vgcreate'"

raid:
  $type: edit-group
  $minItems: 0
  $itemName: RAID ${i}
  $help: RAID (Storage) Subsection for the Yomi Formula
  $prototype:
    $type: group
    $key:
      $name: RAID Device Name
      $type: text
      $placeholder: /dev/md0
      $help: Name of the RAID device
    level:
      $type: select
      $values:
        - linear
        - raid0
        - raid1
        - mirror
        - raid4
        - raid5
        - raid6
        - raid10
        - multipath
        - faulty
        - container
      $default: raid1
      $help: RAID type
    devices:
      $type: edit-group
      $minItems: 1
      $itemName: Device or Partition ${i}
      $help: List of devices or partitions that belong to the RAID
      $prototype:
        name:
          $name: Device or Partition
          $type: text
          $placeholder: /dev/sda1
          $help: Device or partition with type RAID
    metadata:
      $type: select
      $values:
        - 0
        - 0.9
        - 1
        - 1.1
        - 1.2
        - default
        - ddm
        - imsm
      $default: default
      $help: RAID metadata version
    raid-devices:
      $type: number
      $optional: yes
      $help: Number of active devices in array
    spare-devices:
      $type: number
      $optional: yes
      $help: Number of spare (eXtra) devices in initial array

filesystems:
  $type: edit-group
  $minItems: 1
  $itemName: Filesystem ${i}
  $help: File System (Storage) Subsection for the Yomi Formula
  $prototype:
    $type: group
    $key:
      $name: Partition
      $type: text
      $placeholder: /dev/sda1
      $help: Partition for the filesystem
    filesystem:
      $type: select
      $values:
        - swap
        - btrfs
        - xfs
        - ext2
        - ext3
        - ext4
        - vfat
      $default: ext4
      $help: Filesystem for the device
    mountpoint:
      $type: text
      $placeholder: /
      $help: Mount point of the partition
    fat:
      $name: FAT Type
      $type: select
      $values:
        - 12
        - 16
        - 32
      $visibleIf: .filesystem == vfat
      $help: Type of FAT
    subvolumes:
      $name: BtrFS Subvolumes
      $type: group
      $visibleIf: .filesystem == btrfs
      $help: List of Btrfs subvolumes
      prefix:
        $type: text
        $placeholder: '@'
        $help: Btrfs subvolume prefix
      subvolume:
        $type: edit-group
        $minItems: 0
        $itemName: Subvolume ${i}
        $visibleIf: .prefix != ""
        $help: Subvolume description
        $prototype:
          path:
            $type: text
            $placeholder: /root
            $help: Path for the subvolume
          copy_on_write:
            $type: boolean
            $default: yes
            $help: CoW flag
07070100000011000081A40000427000000032000000015F4E04F80000046D000000000000000000000000000000000000004700000000yomi-0.0.1+git.1598948600.9a9eab0/metadata/03-form-yomi-bootloader.yml# Uyuni Form for the Yomi pillar data - Bootloader
#
# Find mode pillar examples in /usr/share/yomi/pillar

bootloader:
  $type: group
  $help: Bootloader Section for the Yomi Formula
  device:
    $type: text
    $placeholder: /dev/sda
    $help: Device where the GRUB2 will be installed
  timeout:
    $type: number
    $optional: yes
    $default: 8
    $help: Value for the GRUB_TIMEOUT parameter
  kernel:
    $type: text
    $optional: yes
    $default: splash=silent quiet
    $help: Line assigned to the GRUB_CMDLINE_LINUX_DEFAULT parameter
  terminal:
    $type: text
    $optional: yes
    $default: gfxterm
    $help: Value for the GRUB_TERMINAL parameter
  serial_command:
    $type: text
    $optional: yes
    $help: Value for the GRUB_SERIAL_COMMAND parameter
  gfxmode:
    $type: text
    $optional: yes
    $default: auto
    $help: Value for the GRUB_GFXMODE parameter
  theme:
    $type: boolean
    $default: no
    $help: Install and configure grub2-branding package
  disable_os_prober:
    $name: Disable OS Prober
    $type: boolean
    $default: no
    $help: Value for the GRUB_DISABLE_OS_PROBER parameter
07070100000012000081A40000427000000032000000015F4E04F800000A69000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/metadata/04-form-yomi-software.yml# Uyuni Form for the Yomi pillar data - Software
#
# Find mode pillar examples in /usr/share/yomi/pillar

software:
  $type: group
  $help: Software Section for the Yomi Formula
  config:
    $name: Configuration
    $type: group
    $help: Local configuration for the software section
    minimal:
      $type: boolean
      $default: no
      $help: Exclude recommended, documentation and multi-version packages
  repositories:
    $type: edit-group
    $minItems: 0
    $help: List of registered repositories
    $prototype:
      $key:
        $name: Repository Name
        $type: text
        $placeholder: repo-oss
        $help: Short name of the repository
      $name: Repository URL
      $type: url
      $placeholder: http://download.opensuse.org/tumbleweed/repo/oss
      $help: URL of the repository
  packages:
    $type: edit-group
    $minItems: 0
    $itemName: Package ${i}
    $help: List of patterns or packages to install
    $prototype:
        $name: Package
        $type: text
        $help: "You can install patterns using the 'pattern:' prefix"
  image:
    $type: group
    $optional: yes
    $help: Image ISO used to dump in the hard disk
    url:
      $name: Image URL
      $type: url
      $help: URL from where download the image
    md5:
      $type: text
      $optional: yes
      $help: MD5 of the image, used for validation

suseconnect:
  $name: SUSEConnect
  $type: group
  $help: SUSEConnect Section for the Yomi Formula
  config:
    $type: group
    $help: Local configuration for the section
    regcode:
      $name: Registration Code
      $type: text
      $help: Subscription registration code for the product
    email:
      $type: text
      $optional: yes
      $help: Email address for product registration
    url:
      $type: url
      $optional: yes
      $placeholder: https://scc.suse.com
      $help: URL of registration server
    version:
      $type: text
      $optional: yes
      $help: Version part of the product name
    arch:
      $name: Architecture
      $type: text
      $optional: yes
      $help: Architecture part of the product name
  products:
    $type: edit-group
    $minItems: 0
    $itemName: Product ${i}
    $help: List of products to register
    $prototype:
      $type: text
      $placeholder: <name>/<version>/<architecture>
      $help: The expected format is <name>/<version>/<architecture>
  packages:
    $type: edit-group
    $minItems: 0
    $itemName: Package ${i}
    $help: List of patterns or packages to install from the products
    $prototype:
        $name: Package
        $type: text
        $help: "You can install patterns using the 'pattern:' prefix"
07070100000013000081A40000427000000032000000015F4E04F800000362000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/metadata/05-form-yomi-services.yml# Uyuni Form for the Yomi pillar data - Services
#
# Find mode pillar examples in /usr/share/yomi/pillar

salt-minion:
  $type: group
  $help: Salt Minion Section for the Yomi Formula
  config:
    $name: Install salt-minion
    $type: boolean
    $default: yes
    $help: (Provisional) Install and configure a salt-minion service

services:
  $type: group
  $help: Service Section for the Yomi Formula
  enabled:
    $type: edit-group
    $minItems: 0
    $itemName: Service ${i}
    $help: List of enabled services
    $prototype:
      $key:
        $type: text
        $name: Service
        $help: Name of the service to enable
  disabled:
    $type: edit-group
    $minItems: 0
    $itemName: Service ${i}
    $help: List of disabled services
    $prototype:
      $key:
        $type: text
        $name: Service
        $help: Name of the service to disable
07070100000014000081A40000427000000032000000015F4E04F8000002CC000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/metadata/06-form-yomi-users.yml# Uyuni Form for the Yomi pillar data - Users
#
# Find mode pillar examples in /usr/share/yomi/pillar

users:
  $type: edit-group
  $minItems: 1
  $itemName: User ${i}
  $help: List of users of the system
  $prototype:
    username:
      $type: text
    password:
      $name: Password Hash
      $type: text
      $help: "You can generate a hash with 'openssl passwd -1 -salt <salt> <password>'"
    certificates:
      $type: edit-group
      $minItems: 0
      $itemName: Certificate ${i}
      $prototype:
        $key:
          $name: Certificate
          $type: text
          $help: "Will be added to .ssh/authorized_keys. Use only the encoded key (remove the 'ssh-rsa' prefix and the 'user@host' suffix)"
07070100000015000081A40000427000000032000000015F4E04F80000003E000000000000000000000000000000000000003800000000yomi-0.0.1+git.1598948600.9a9eab0/metadata/metadata.ymldescription:
  Yet one more installer
group: installer
#AFTER
07070100000016000081ED0000427000000032000000015F4E04F800003A07000000000000000000000000000000000000002A00000000yomi-0.0.1+git.1598948600.9a9eab0/monitor#!/usr/bin/python3

import argparse
import getpass
import json
import logging
import os
from pathlib import Path
import pprint
import ssl
import sys
import time
import urllib.error
import urllib.parse
import urllib.request

LOG = logging.getLogger(__name__)
TOKEN_FILE = "~/.salt-api-token"

# ANSI color codes
BLACK = "\033[1;30m"
RED = "\033[1;31m"
GREEN = "\033[0;32m"
YELLOW = "\033[0;33m"
BLUE = "\033[1;34m"
MAGENTA = "\033[1;35m"
CYAN = "\033[1;36m"
WHITE = "\033[1;37m"
RESET = "\033[0;0m"

class SaltAPI:
    def __init__(
        self,
        url,
        username,
        password,
        eauth,
        insecure,
        token_file=TOKEN_FILE,
        debug=False,
    ):
        self.url = url
        self.username = username
        self.password = password
        self.eauth = eauth
        self.insecure = insecure
        self.token_file = token_file
        self.debug = debug

is_https = urllib.parse.urlparse(url).scheme == "https"
        if debug or (is_https and insecure):
            if insecure:
                context = ssl._create_unverified_context()
                handler = urllib.request.HTTPSHandler(
                    context=context, debuglevel=int(debug)
                )
            else:
                handler = urllib.request.HTTPHandler(debuglevel=int(debug))
            opener = urllib.request.build_opener(handler)
            urllib.request.install_opener(opener)

self.token = None
        self.expire = 0.0

def login(self, remove=False):
        """Login into the Salt API service."""
        if remove:
            self._drop_token()
        self.token, self.expire = self._read_token()
        if self.expire < time.time() + 30:
            self.token, self.expire = self._login()
            self._write_token()

def logout(self):
        """Logout from the Salt API service."""
        self._drop_token()
        self._post("/logout")

def events(self):
        """SSE event stream from Salt API service."""
        for line in api._req_sse("/events", None, "GET"):
            line = line.decode("utf-8").strip()
            if not line or line.startswith((":", "retry:")):
                continue
            key, value = line.split(":", 1)
            if key == "tag":
                tag = value.strip()
                continue
            if key == "data":
                data = json.loads(value)
                yield (tag, data)

def minions(self, mid=None):
        """Return the list of minions."""
        if mid:
            action = "/minions/{}".format(mid)
        else:
            action = "/minions"
        return self._get(action)["return"][0]

def run_job(self, tgt, fun, **kwargs):
        """Start an execution command and return jid."""
        data = {
            "tgt": tgt,
            "fun": fun,
        }
        data.update(kwargs)
        return self._post("/minions", data)["return"][0]

def jobs(self, jid=None):
        """Return the list of jobs."""
        if jid:
            action = "/jobs/{}".format(jid)
        else:
            action = "/jobs"
        return self._get(action)["return"][0]

def stats(self):
        """Return a dump of statistics."""
        return self._get("/stats")["return"][0]

def _login(self):
        """Login into the Salt API service."""
        data = {
            "username": self.username,
            "password": self.password,
            "eauth": self.eauth,
        }
        result = self._post("/login", data)
        return result["return"][0]["token"], result["return"][0]["expire"]

def _get(self, action, data=None):
        return self._req(action, data, "GET")

def _post(self, action, data=None):
        return self._req(action, data, "POST")

def _req(self, action, data, method):
        """HTTP GET / POST to Salt API."""
        headers = {
            "User-Agent": "salt-autoinstaller monitor",
            "Accept": "application/json",
            "Content-Type": "application/json",
            "X-Requested-With": "XMLHttpRequest",
        }
        if self.token:
            headers["X-Auth-Token"] = self.token

url = urllib.parse.urljoin(self.url, action)
        if method == "GET":
            data = urllib.parse.urlencode(data).encode() if data else None
            if data:
                url = "{}?{}".format(url, data)
            data = None
        elif method == "POST":
            data = json.dumps(data).encode() if data else {}
        else:
            raise ValueError("Method {} not valid".format(method))

result = {}
        try:
            request = urllib.request.Request(url, data, headers)
            with urllib.request.urlopen(request) as response:
                result = json.loads(response.read().decode("utf-8"))
        except (urllib.error.HTTPError, urllib.error.URLError) as exc:
            LOG.debug("Error with request", exc_info=True)
            status = getattr(exc, "code", None)

if status == 401:
                print("Authentication denied")

if status == 500:
                print("Server error.")
            exit(-1)
        return result

def _req_sse(self, action, data, method):
        """HTTP SSE GET / POST to Salt API."""
        headers = {
            "User-Agent": "salt-autoinstaller monitor",
            "Accept": "text/event-stream",
            "Content-Type": "application/json",
            "Connection": "Keep-Alive",
            "X-Requested-With": "XMLHttpRequest",
        }
        if self.token:
            headers["X-Auth-Token"] = self.token

try:
            request = urllib.request.Request(url, data, headers)
            with urllib.request.urlopen(request) as response:
                yield from response
        except (urllib.error.HTTPError, urllib.error.URLError) as e:
            LOG.debug("Error with request", exc_info=True)
            status = getattr(e, "code", None)

if status == 401:
                print("Authentication denied")

if status == 500:
                print("Server error.")
            exit(-1)

def _read_token(self):
        """Return the token and expire time from the token file."""
        token, expire = None, 0.0

if self.token_file:
            token_path = Path(self.token_file).expanduser()
            if token_path.is_file():
                token, expire = token_path.read_text().split()
                try:
                    expire = float(expire)
                except ValueError:
                    expire = 0.0

return token, expire

def _write_token(self):
        """Save the token and expire time into the token file."""
        self._drop_token()
        if self.token_file:
            token_path = Path(self.token_file).expanduser()
            token_path.touch(mode=0o600)
            token_path.write_text("{} {}".format(self.token, self.expire))

def _drop_token(self):
        """Remove the token file if present."""
        if self.token_file:
            token_path = Path(self.token_file).expanduser()
            if token_path.is_file():
                token_path.unlink()

def print_minions(minions):
    """Print a list of minions."""
    print("Registered minions:")
    for minion in minions:
        print("- {}".format(minion))

def print_minion(minion):
    """Print detailed information of a minion."""
    pprint.pprint(minion)

def print_jobs(jobs):
    """Print a list of jobs."""
    print("Registered jobs:")
    for job, info in jobs.items():
        print("- {}".format(job))
        pprint.pprint(info)

def print_job(job):
    """Print detailed information of a job."""
    pprint.pprint(job)

def print_raw_event(tag, data):
    """Print raw event without format."""
    print("- {}".format(tag))
    pprint.pprint(data)

def print_yomi_event(tag, data):
    """Print a Yomi event with format."""
    if tag.startswith("yomi/"):
        id_ = data["data"]["id"]
        stamp = data["data"]["_stamp"]

# Decide the color to represent the node
        if id_ in print_yomi_event.nodes:
            color = print_yomi_event.nodes[id_]
        else:
            color = print_yomi_event.colors.pop()
            print_yomi_event.colors.insert(0, color)
            print_yomi_event.nodes[id_] = color

tag = tag.split("/", 1)[1]
        tag, section = tag.rsplit("/", 1)
        if section == "enter":
            print(
                "[{}{}{}] {} -> [{}STARTING{}] {}".format(
                    color, id_, RESET, stamp, BLUE, RESET, tag
                )
            )
        elif section == "success":
            print(
                "[{}{}{}] {} -> [{}SUCCESS{}]  {}".format(
                    color, id_, RESET, stamp, GREEN, RESET, tag
                )
            )
        elif section == "fail":
            print(
                "[{}{}{}] {} -> [{}FAIL{}]     {}".format(
                    color, id_, RESET, stamp, RED, RESET, tag
                )
            )

# Static-a-like variables to track the rotating color
print_yomi_event.nodes = {}
print_yomi_event.colors = [RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN]

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="salt-autoinstaller monitor tool via salt-api."
    )
    parser.add_argument(
        "-u",
        "--saltapi-url",
        default=os.environ.get("SALTAPI_URL", "https://localhost:8000"),
        help="Specify the host url. Overwrite SALTAPI_URL.",
    )
    parser.add_argument(
        "-a",
        "--auth",
        "--eauth",
        "--extended-auth",
        default=os.environ.get("SALTAPI_EAUTH", "pam"),
        help="Specify the external_auth backend to "
        "authenticate against and interactively prompt "
        "for credentials. Overwrite SALTAPI_EAUTH.",
    )
    parser.add_argument(
        "-n",
        "--username",
        default=os.environ.get("SALTAPI_USER"),
        help="Optional, defaults to user name. will "
        "be prompt if empty unless --non-interactive. "
        "Overwrite SALTAPI_USER.",
    )
    parser.add_argument(
        "-p",
        "--password",
        default=os.environ.get("SALTAPI_PASS"),
        help="Optional, but will be prompted unless "
        "--non-interactive. Overwrite SALTAPI_PASS.",
    )
    parser.add_argument(
        "--non-interactive",
        action="store_true",
        default=False,
        help="Optional, fail rather than waiting for input.",
    )
    parser.add_argument(
        "-r",
        "--remove",
        action="store_true",
        default=False,
        help="Remove the token cached in the system.",
    )
    parser.add_argument(
        "-i",
        "--insecure",
        action="store_true",
        default=False,
        help="Ignore any SSL certificate that may be "
        "encountered. Note that it is recommended to resolve "
        "certificate errors for production.",
    )
    parser.add_argument(
        "-H",
        "--debug-http",
        action="store_true",
        default=False,
        help=("Output the HTTP request/response headers on " "stderr."),
    )
    parser.add_argument(
        "-m",
        "--minions",
        action="store_true",
        default=False,
        help="List available minions.",
    )
    parser.add_argument(
        "--show-minion",
        metavar="MID",
        default=None,
        help="Show the details of a minion.",
    )
    parser.add_argument(
        "-j", "--jobs", action="store_true", default=False, help="List available jobs."
    )
    parser.add_argument(
        "--show-job", metavar="JID", default=None, help="Show the details of a job."
    )
    parser.add_argument(
        "-e",
        "--events",
        action="store_true",
        default=False,
        help="Show events from salt-master.",
    )
    parser.add_argument(
        "-y",
        "--yomi-events",
        action="store_true",
        default=False,
        help="Show only Yomi events from salt-master.",
    )
    parser.add_argument(
        "target", nargs="?", help="Minion ID where to launch the installer."
    )
    args = parser.parse_args()

if not args.saltapi_url:
        print("Please, provide a valid Salt API URL", file=sys.stderr)
        exit(-1)

if args.non_interactive:
        if args.username is None:
            print("Please, provide a valid user name", file=sys.stderr)
            exit(-1)

if args.password is None:
            print("Please, provide a valid password", file=sys.stderr)
            exit(-1)
    else:
        if args.username is None:
            args.username = input("Username: ")
        if args.password is None:
            args.password = getpass.getpass(prompt="Password: ")

api = SaltAPI(
        url=args.saltapi_url,
        username=args.username,
        password=args.password,
        eauth=args.auth,
        insecure=args.insecure,
        debug=args.debug_http,
    )

api.login(args.remove)

if args.minions:
        print_minions(api.minions())

if args.show_minion:
        print_minion(api.minions(args.show_minion))

if args.jobs:
        print_jobs(api.jobs())

if args.show_job:
        print_job(api.jobs(args.show_job))

if args.target:
        print_job(api.run_job(args.target, "state.highstate"))

if args.events or args.yomi_events:
        for tag, data in api.events():
            if args.yomi_events:
                print_yomi_event(tag, data)
            else:
                print_raw_event(tag, data)
07070100000017000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000002900000000yomi-0.0.1+git.1598948600.9a9eab0/pillar070701000000180000A1FF0000427000000032000000015F2040CC00000013000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/_storage.sls.image_storage.sls.single070701000000190000A1FF0000427000000032000000015F2040CC00000014000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/_storage.sls.kubic_storage.sls.microos0707010000001A000081A40000427000000032000000015F4E04F8000009C6000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/_storage.sls.lvm#
# Storage section for a LVM with three devices deployment
#

partitions:
  config:
    label: {{ partition }}
    # Same gap for all devices
    initial_gap: 1MB
  devices:
    /dev/{{ device_type }}a:
      partitions:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 1MB
          type: boot
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 256MB
          type: efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
        - number: {{ next_partition }}
          size: rest
          type: lvm
    /dev/{{ device_type }}b:
      partitions:
        - number: 1
          size: rest
          type: lvm
    /dev/{{ device_type }}c:
      partitions:
        - number: 1
          size: rest
          type: lvm

lvm:
  system:
    devices:
      - /dev/{{ device_type }}a{{ 2 if efi else 1 }}
      - /dev/{{ device_type }}b1
      - name: /dev/{{ device_type }}c1
        dataalignmentoffset: 7s
    clustered: 'n'
    volumes:
{% if swap %}
      - name: swap
        size: 1024M
{% endif %}
      - name: root
{% if home_filesystem %}
        size: 16384M
{% else %}
        extents: 100%FREE
{% endif %}
{% if home_filesystem %}
      - name: home
        extents: 100%FREE
{% endif %}

filesystems:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: vfat
    mountpoint: /boot/efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
  /dev/system/swap:
    filesystem: swap
  /dev/system/root:
    filesystem: {{ root_filesystem }}
    mountpoint: /
{% if root_filesystem == 'btrfs' %}
    subvolumes:
      prefix: '@'
      subvolume:
  {% if not home_filesystem %}
        - path: home
  {% endif %}
        - path: opt
        - path: root
        - path: srv
        - path: tmp
        - path: usr/local
        - path: var
          copy_on_write: no
    {% if arch == 'aarch64' %}
        - path: boot/grub2/arm64-efi
    {% else %}
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
    {% endif %}
{% endif %}
{% if home_filesystem %}
  /dev/system/home:
    filesystem: {{ home_filesystem }}
    mountpoint: /home
{% endif %}

bootloader:
  device: /dev/{{ device_type }}a
  theme: yes
0707010000001B000081A40000427000000032000000015F4E04F800000926000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/_storage.sls.microos#
# Storage section for a microos deployment in a single device
#

{% if swap %}
  {{ raise ('Do not define a SWAP partition for MicoOS') }}
{% endif %}
{% if home_filesystem %}
  {{ raise ('Do not define a separate home partition for MicoOS') }}
{% endif %}
{% if root_filesystem != 'btrfs' %}
  {{ raise ('File system must be BtrFS for MicoOS') }}
{% endif %}
{% if not snapper %}
  {{ raise ('Snapper is required for MicoOS') }}
{% endif %}

partitions:
  config:
    label: {{ partition }}
  devices:
    /dev/{{ device_type }}a:
      initial_gap: 1MB
      partitions:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 1MB
          type: boot
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 256MB
          type: efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
        - number: {{ next_partition }}
          size: 16384MB
          type: linux
{% set next_partition = next_partition + 1 %}
        - number: {{ next_partition }}
          size: rest
          type: linux
{% set next_partition = next_partition + 1 %}

filesystems:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: vfat
    mountpoint: /boot/efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: {{ root_filesystem }}
    mountpoint: /
    options: [ro]
    subvolumes:
      prefix: '@'
      subvolume:
        - path: root
        - path: home
        - path: opt
        - path: srv
        - path: boot/writable
        - path: usr/local
    {% if arch == 'aarch64' %}
        - path: boot/grub2/arm64-efi
    {% else %}
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
    {% endif %}
{% set next_partition = next_partition + 1 %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: {{ root_filesystem }}
    mountpoint: /var
{% set next_partition = next_partition + 1 %}

bootloader:
  device: /dev/{{ device_type }}a
  kernel: swapaccount=1
  disable_os_prober: yes
  theme: yes
0707010000001C000081A40000427000000032000000015F4E04F800000B49000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/_storage.sls.raid1#
# Storage section for a RAID 1 with three devices deployment
#

partitions:
  config:
    label: gpt
    # Same gap for all devices
    initial_gap: 1MB
  devices:
    /dev/{{ device_type }}a:
      partitions:
        - number: 1
          size: rest
          type: raid
    /dev/{{ device_type }}b:
      partitions:
        - number: 1
          size: rest
          type: raid
    /dev/{{ device_type }}c:
      partitions:
        - number: 1
          size: rest
          type: raid
    /dev/md0:
      partitions:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 1MB
          type: boot
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 256MB
          type: efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if swap %}
        - number: {{ next_partition }}
          size: 1024MB
          type: swap
  {% set next_partition = next_partition + 1 %}
{% endif %}
        - number: {{ next_partition }}
          size: {{ 'rest' if not home_filesystem else '16384MB' }}
          type: linux
{% set next_partition = next_partition + 1 %}
{% if home_filesystem %}
        - number: {{ next_partition }}
          size: rest
          type: linux
  {% set next_partition = next_partition + 1 %}
{% endif %}

raid:
  /dev/md0:
    level: 1
    devices:
      - /dev/{{ device_type }}a1
      - /dev/{{ device_type }}b1
      - /dev/{{ device_type }}c1
    spare-devices: 1
    metadata: 1.0

filesystems:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
  /dev/md0p{{ next_partition }}:
    filesystem: vfat
    mountpoint: /boot/efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if swap %}
  /dev/md0p{{ next_partition }}:
    filesystem: swap
  {% set next_partition = next_partition + 1 %}
{% endif %}
  /dev/md0p{{ next_partition }}:
    filesystem: {{ root_filesystem }}
    mountpoint: /
{% if root_filesystem == 'btrfs' %}
    subvolumes:
      prefix: '@'
      subvolume:
  {% if not home_filesystem %}
        - path: home
  {% endif %}
        - path: opt
        - path: root
        - path: srv
        - path: tmp
        - path: usr/local
        - path: var
          copy_on_write: no
    {% if arch == 'aarch64' %}
        - path: boot/grub2/arm64-efi
    {% else %}
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
    {% endif %}
{% endif %}
{% set next_partition = next_partition + 1 %}
{% if home_filesystem %}
  /dev/md0p{{ next_partition }}:
    filesystem: {{ home_filesystem }}
    mountpoint: /home
  {% set next_partition = next_partition + 1 %}
{% endif %}

bootloader:
  device: /dev/md0
  theme: yes
0707010000001D000081A40000427000000032000000015F4E04F800000984000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/_storage.sls.single#
# Storage section for a single device deployment
#

partitions:
  config:
    label: {{ partition }}
  devices:
    /dev/{{ device_type }}a:
      initial_gap: 1MB
      partitions:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 1MB
          type: boot
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
        - number: {{ next_partition }}
          size: 256MB
          type: efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if swap %}
        - number: {{ next_partition }}
          size: 1024MB
          type: swap
  {% set next_partition = next_partition + 1 %}
{% endif %}
        - number: {{ next_partition }}
          size: {{ 'rest' if not home_filesystem else '16384MB' }}
          type: linux
{% set next_partition = next_partition + 1 %}
{% if home_filesystem %}
        - number: {{ next_partition }}
          size: rest
          type: linux
  {% set next_partition = next_partition + 1 %}
{% endif %}

filesystems:
{% set next_partition = 1 %}
{% if not efi and partition == 'gpt' %}
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if efi and partition == 'gpt' %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: vfat
    mountpoint: /boot/efi
  {% set next_partition = next_partition + 1 %}
{% endif %}
{% if swap %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: swap
  {% set next_partition = next_partition + 1 %}
{% endif %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: {{ root_filesystem }}
    mountpoint: /
{% if root_filesystem == 'btrfs' %}
    subvolumes:
      prefix: '@'
      subvolume:
  {% if not home_filesystem %}
        - path: home
  {% endif %}
        - path: opt
        - path: root
        - path: srv
        - path: tmp
        - path: usr/local
        - path: var
          copy_on_write: no
    {% if arch == 'aarch64' %}
        - path: boot/grub2/arm64-efi
    {% else %}
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
    {% endif %}
{% endif %}
{% set next_partition = next_partition + 1 %}
{% if home_filesystem %}
  /dev/{{ device_type }}a{{ next_partition }}:
    filesystem: {{ home_filesystem }}
    mountpoint: /home
  {% set next_partition = next_partition + 1 %}
{% endif %}

bootloader:
  device: /dev/{{ device_type }}a
  theme: yes
0707010000001E0000A1FF0000427000000032000000015F2040CC00000013000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/_storage.sls.sles_storage.sls.single0707010000001F000081A40000427000000032000000015F4E04F800000E36000000000000000000000000000000000000003700000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/installer.sls# Meta pillar for testing Yomi
#
# There are some parameters that can be configured and adapted to
# launch a basic Yomi installation:
#
#   * efi = {True, False}
#   * partition = {'msdos', 'gpt'}
#   * device_type = {'sd', 'hd', 'vd'}
#   * root_filesystem = {'ext{2, 3, 4}', 'btrfs'}
#   * home_filesystem = {'ext{2, 3, 4}', 'xfs', False}
#   * snapper = {True, False}
#   * swap = {True, False}
#   * mode = {'single', 'lvm', 'raid{0, 1, 4, 5, 6, 10}', 'microos',
#             'kubic', 'image', 'sles'}
#   * network = {'auto', 'eth0', 'ens3', ... }
#
# This meta-pillar can be used as a template for new installers. This
# template is expected to be adapted for production systems, as was
# designed for CI / QA and development.

# We cannot access to grains['efi'] from the pillar, as this is not
# yet synchronized
{% set efi = True %}
{% set partition = 'gpt' %}
{% set device_type = 'sd' %}
{% set root_filesystem = 'btrfs' %}
{% set home_filesystem = False %}
{% set snapper = True %}
{% set swap = False %}
{% set mode = 'microos' %}
{% set network = 'auto' %}

{% set arch = grains['cpuarch'] %}

config:
  events: no
  reboot: yes
{% if snapper and root_filesystem == 'btrfs' %}
  snapper: yes
{% endif %}
  locale: en_US.UTF-8
  keymap: us
  timezone: UTC
  hostname: node

{% include "_storage.sls.%s" % mode %}

{% if mode == 'sles' %}
suseconnect:
  config:
    regcode: REGISTRATION-CODE
    version: '15.1'
    arch: {{ arch }}
  products:
    - sle-module-basesystem
    - sle-module-server-applications
{% endif %}

software:
  config:
    minimal: {{ 'yes' if mode in ('microos', 'kubic') else 'no' }}
  repositories:
{% if mode == 'sles' %}
    SUSE_SLE-15_GA: "http://download.suse.de/ibs/SUSE:/SLE-15:/GA/standard/"
    SUSE_SLE-15-SP1_GA: "http://download.suse.de/ibs/SUSE:/SLE-15-SP1:/GA/standard/"
{% elif arch == 'aarch64' %}
    repo-oss: "http://download.opensuse.org/ports/aarch64/tumbleweed/repo/oss/"
{% else %}
    repo-oss: "http://download.opensuse.org/tumbleweed/repo/oss/"
{% endif %}
{% if mode == 'image' %}
  image:
    url: tftp://10.0.3.1/openSUSE-Tumbleweed-Yomi{{ arch }}-1.0.0.xz
    md5:
{% else %}
  packages:
  {% if mode == 'microos' %}
    - pattern:microos_base
    - pattern:microos_defaults
    - pattern:microos_hardware
  {% elif mode == 'kubic' %}
    - pattern:microos_base
    - pattern:microos_defaults
    - pattern:microos_hardware
    - pattern:microos_apparmor
    - pattern:kubic_worker
  {% elif mode == 'sles' %}
    - product:SLES
    - pattern:base
    - pattern:enhanced_base
    - pattern:yast2_basis
    - pattern:x11_yast
    - pattern:x11
    - pattern:gnome_basic
  {% else %}
    - pattern:enhanced_base
    - glibc-locale
  {% endif %}
    - kernel-default
{% endif %}

salt-minion:
  config: yes

services:
  enabled:
{% if mode == 'kubic' %}
    - crio
    - kubelet
{% endif %}
    - salt-minion

{% if network != 'auto' %}
networks:
  - interface: {{ network }}
{% endif %}

users:
  - username: root
    # Set the password as 'linux'. Do not do that in production
    password: "$1$wYJUgpM5$RXMMeASDc035eX.NbYWFl0"
    # Personal certificate, without the type prefix nor the host
    # suffix
    certificates:
      - "AAAAB3NzaC1yc2EAAAADAQABAAABAQDdP6oez825gnOLVZu70KqJXpqL4fGf\
        aFNk87GSk3xLRjixGtr013+hcN03ZRKU0/2S7J0T/dICc2dhG9xAqa/A31Qac\
        hQeg2RhPxM2SL+wgzx0geDmf6XDhhe8reos5jgzw6Pq59gyWfurlZaMEZAoOY\
        kfNb5OG4vQQN8Z7hldx+DBANPbylApurVz6h5vvRrkPfuRVN5ZxOkI+LeWhpo\
        vX5XK3eTjetAwWEro6AAXpGoQQQDjSOoYHCUmXzcZkmIWEubCZvAI4RZ+XCZs\
        +wTeO2RIRsunqP8J+XW4cZ28RZBc9K4I1BV8C6wBxN328LRQcilzw+Me+Lfre\
        eDPglqx"
07070100000020000081A40000427000000032000000015F4E04F80000001D000000000000000000000000000000000000003100000000yomi-0.0.1+git.1598948600.9a9eab0/pillar/top.slsbase:
  '*':
    - installer
07070100000021000041ED0000427000000032000000075F4E04F800000000000000000000000000000000000000000000002700000000yomi-0.0.1+git.1598948600.9a9eab0/salt07070100000022000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000002F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_grains07070100000023000081A40000427000000032000000015F4E04F800000551000000000000000000000000000000000000003600000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_grains/efi.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import glob
import os.path

def __secure_boot():
    """Detect if secure-boot is enabled."""
    enabled = False
    sboot = glob.glob("/sys/firmware/efi/vars/SecureBoot-*/data")
    if len(sboot) == 1:
        enabled = open(sboot[0], "rb").read()[-1:] == b"\x01"
    return enabled

def uefi():
    """Populate UEFI grains."""
    grains = {
        "efi": os.path.exists("/sys/firmware/efi/systab"),
        "efi-secure-boot": __secure_boot(),
    }

return grains
07070100000024000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003000000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_modules07070100000025000081A40000427000000032000000015F4E04F800002BEA000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_modules/devices.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

"""
:maintainer:    Alberto Planas <aplanas@suse.com>
:maturity:      new
:depends:       None
:platform:      Linux
"""
from __future__ import absolute_import, print_function, unicode_literals
import logging

LOG = logging.getLogger(__name__)

__virtualname__ = "devices"

__func_alias__ = {
    "filter_": "filter",
}

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __grains__
    __salt__
except NameError:
    __grains__ = {}
    __salt__ = {}

def _udev(udev_info, key):
    """
    Return the value for a udev key.

The `key` parameter is a lower case text joined by dots. For
    example, 'e.id_bus' will represent the key for
    `udev_info['E']['ID_BUS']`.

"""
    k, _, r = key.partition(".")
    if not k:
        return udev_info
    if not isinstance(udev_info, dict):
        return "n/a"
    if not r:
        return udev_info.get(k.upper(), "n/a")
    return _udev(udev_info.get(k.upper(), {}), r)

def _match(udev_info, match_info):
    """
    Check if `udev_info` match the information from `match_info`.
    """
    res = True
    for key, value in match_info.items():
        udev_value = _udev(udev_info, key)
        if isinstance(udev_value, dict):
            # If is a dict we probably make a mistake in key from
            # match_info, as is not accessing a final value
            LOG.warning(
                "The key %s for the udev information "
                "dictionary is not a leaf element",
                key,
            )
            continue

# Converting both values to sets make easy to see if there is
        # a coincidence between both values
        value = set(value) if isinstance(value, list) else set([value])
        udev_value = (
            set(udev_value) if isinstance(udev_value, list) else set([udev_value])
        )
        res = res and (value & udev_value)
    return res

def filter_(udev_in=None, udev_ex=None):
    """
    Returns a list of devices, filtered under udev keys.

udev_in
        A dictionary of key:values that are expected in the device
        udev information

udev_ex
        A dictionary of key:values that are not expected in the device
        udev information (excluded)

The key is a lower case string, joined by dots, that represent a
    path in the udev information dictionary. For example, 'e.id_bus'
    will represent the udev entry `udev['E']['ID_BUS']

If the udev entry is a list, the algorithm will check that at
    least one item match one item of the value of the parameters.

Returns list of devices that match `udev_in` and do not match
    `udev_ex`.

CLI Example:

.. code-block:: bash

salt '*' devices.filter udev_in='{"e.id_bus": "ata"}'

"""

udev_in = udev_in if udev_in else {}
    udev_ex = udev_ex if udev_ex else {}

all_devices = __grains__["disks"]

# Get the udev information only one time
    udev_info = {d: __salt__["udev.info"](d) for d in all_devices}

devices_udev_key_in = {d for d in all_devices if _match(udev_info[d], udev_in)}
    devices_udev_key_ex = {
        d for d in all_devices if _match(udev_info[d], udev_ex) if udev_ex
    }

return sorted(devices_udev_key_in - devices_udev_key_ex)

def wipe(device):
    """
    Remove all the partitions in the device.

device
        Device name, for example /dev/sda

Remove all the partitions, labels and flags from the device.

CLI Example:

.. code-block:: bash

salt '*' devices.wipeout /dev/sda

"""

partitions = __salt__["partition.list"](device).get("partitions", [])
    for partition in partitions:
        # Remove filesystem information the the partition
        __salt__["disk.wipe"]("{}{}".format(device, partition))
        __salt__["partition.rm"](device, partition)

# Remove the MBR information
    __salt__["disk.wipe"]("{}".format(device))
    __salt__["cmd.run"]("dd bs=512 count=1 if=/dev/zero of={}".format(device))

return True

def _hwinfo_parse_short(report):
    """Parse the output of hwinfo and return a dictionary"""
    result = {}
    current_result = {}
    key_counter = 0
    for line in report.strip().splitlines():
        if line.startswith("    "):
            key = key_counter
            key_counter += 1
            current_result[key] = line.strip()
        elif line.startswith("  "):
            key, value = line.strip().split(" ", 1)
            current_result[key] = value.strip()
        elif line.endswith(":"):
            key = line[:-1]
            value = {}
            result[key] = value
            current_result = value
            key_counter = 0
        else:
            LOG.error("Error parsing hwinfo short output: {}".format(line))

return result

def _hwinfo_parse_full(report):
    """Parse the output of hwinfo and return a dictionary"""
    result = {}
    result_stack = []
    level = 0
    for line in report.strip().splitlines():
        current_level = line.count("  ")
        if level != current_level or len(result_stack) != result_stack:
            result_stack = result_stack[:current_level]
            level = current_level
        line = line.strip()

# Ignore empty lines
        if not line:
            continue

# Initial line of a segment
        if level == 0:
            key, value = line.split(":", 1)
            sub_result = {}
            result[key] = sub_result
            # The first line contains also a sub-element
            key, value = value.strip().split(": ", 1)
            sub_result[key] = value
            result_stack.append(sub_result)
            level += 1
            continue

# Line is a note
        if line.startswith("[") or ":" not in line:
            sub_result = result_stack[-1]
            sub_result["Note"] = line if not line.startswith("[") else line[1:-1]
            continue

key, value = line.split(":", 1)
        key, value = key.strip(), value.strip()
        sub_result = result_stack[-1]
        # If there is a value and it not starts with hash, this is a
        # (key, value) entry. But there are exception on the rule,
        # like when is about 'El Torito info', that is the begining of
        # a new dictorionart.
        if value and not value.startswith("#") and key != "El Torito info":
            if key == "I/O Port":
                key = "I/O Ports"
            elif key == "Config Status":
                value = dict(item.split("=") for item in value.split(", "))
            elif key in ("Driver", "Driver Modules"):
                value = value.replace('"', "").split(", ")
            elif key in ("Tags", "Device Files", "Features"):
                # We cannot split by ', ', as using spaces in
                # inconsisten in some fields
                value = [v.strip() for v in value.split(",")]
            else:
                if value.startswith('"'):
                    value = value[1:-1]

# If there is a collision, we store it as a list
            if key in sub_result:
                current_value = sub_result[key]
                if type(current_value) is not list:
                    current_value = [current_value]
                if value not in current_value:
                    current_value.append(value)
                if len(current_value) == 1:
                    value = current_value[0]
                else:
                    value = current_value
            sub_result[key] = value
        else:
            if value.startswith("#"):
                value = {"Handle": value}
            elif key == "El Torito info":
                value = value.split(", ")
                value = {
                    "platform": value[0].split()[-1],
                    "bootable": "no" if "not" in value[1] else "yes",
                }
            else:
                value = {}

sub_result[key] = value
            result_stack.append(value)
            level += 1

return result

def _hwinfo_parse(report, short):
    """Parse the output of hwinfo and return a dictionary"""
    if short:
        return _hwinfo_parse_short(report)
    else:
        return _hwinfo_parse_full(report)

def _hwinfo_efi():
    """Return information about EFI"""
    return {
        "efi": __grains__["efi"],
        "efi-secure-boot": __grains__["efi-secure-boot"],
    }

def _hwinfo_memory():
    """Return information about the memory"""
    return {
        "mem_total": __grains__["mem_total"],
    }

def _hwinfo_network(short):
    """Return network information"""
    info = {
        "fqdn": __grains__["fqdn"],
        "ip_interfaces": __grains__["ip_interfaces"],
    }

if not short:
        info["dns"] = __grains__["dns"]

return info

def hwinfo(items=None, short=True, listmd=False, devices=None):
    """
    Probe for hardware

items
        List of hardware items to inspect. Default ['bios', 'cpu', 'disk',
        'memory', 'network', 'partition']

short
        Show only a summary. Default True.

listmd
        Report RAID devices. Default False.

devices
        List of devices to show information from. Default None.

CLI Example:

.. code-block:: bash

salt '*' devices.hwinfo
       salt '*' devices.hwinfo items='["disk"]' short=no
       salt '*' devices.hwinfo items='["disk"]' short=no devices='["/dev/sda"]'
       salt '*' devices.hwinfo devices=/dev/sda

"""
    result = {}

if not items:
        items = ["bios", "cpu", "disk", "memory", "network", "partition"]
    if not isinstance(items, (list, tuple)):
        items = [items]

if not devices:
        devices = []
    if devices and not isinstance(devices, (list, tuple)):
        devices = [devices]

cmd = ["hwinfo"]
    for item in items:
        cmd.append("--{}".format(item))

if short:
        cmd.append("--short")

if listmd:
        cmd.append("--listmd")

for device in devices:
        cmd.append("--only {}".format(device))

out = __salt__["cmd.run_stdout"](cmd)
    result["hwinfo"] = _hwinfo_parse(out, short)

if "bios" in items:
        result["bios grains"] = _hwinfo_efi()

if "memory" in items:
        result["memory grains"] = _hwinfo_memory()

if "network" in items:
        result["network grains"] = _hwinfo_network(short)

return result
07070100000026000081A40000427000000032000000015F4E04F800000703000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_modules/filters.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

LOG = logging.getLogger(__name__)

__virtualname__ = "filters"

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __pillar__
except NameError:
    __pillar__ = {}

def is_lvm(device):
    """Detect if a device name comes from a LVM volume."""
    devices = ["/dev/{}/".format(i) for i in __pillar__.get("lvm", {})]
    devices.extend(("/dev/mapper/", "/dev/dm-"))
    return device.startswith(tuple(devices))

def is_raid(device):
    """Detect if a device name comes from a RAID array."""
    return device.startswith("/dev/md")

def is_not_raid(device):
    """Detect if a device name comes from a RAID array."""
    return not is_raid(device)
07070100000027000081A40000427000000032000000015F4E04F800001F5D000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_modules/images.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

from salt.exceptions import SaltInvocationError, CommandExecutionError
import salt.utils.args

LOG = logging.getLogger(__name__)

__virtualname__ = "images"

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __salt__
except NameError:
    __salt__ = {}

VALID_SCHEME = (
    "dict",
    "file",
    "ftp",
    "ftps",
    "gopher",
    "http",
    "https",
    "imap",
    "imaps",
    "ldap",
    "ldaps",
    "pop3",
    "pop3s",
    "rtmp",
    "rtsp",
    "scp",
    "sftp",
    "smb",
    "smbs",
    "smtp",
    "smtps",
    "telnet",
    "tftp",
)
VALID_COMPRESSIONS = ("gz", "bz2", "xz")
VALID_CHECKSUMS = ("md5", "sha1", "sha224", "sha256", "sha384", "sha512")

def _checksum_url(url, checksum_type):
    """Generate the URL for the checksum"""
    url_elements = urllib.parse.urlparse(url)
    path = url_elements.path
    suffix = pathlib.Path(path).suffix
    new_suffix = ".{}".format(checksum_type)
    if suffix[1:] in VALID_COMPRESSIONS:
        path = pathlib.Path(path).with_suffix(new_suffix)
    else:
        path = pathlib.Path(path).with_suffix(suffix + new_suffix)
    return urllib.parse.urlunparse(url_elements._replace(path=str(path)))

def _curl_cmd(url, **kwargs):
    """Return curl commmand line"""
    cmd = ["curl"]
    for key, value in salt.utils.args.clean_kwargs(**kwargs).items():
        if len(key) == 1:
            cmd.append("-{}".format(key))
        else:
            cmd.append("--{}".format(key))
        if value is not None:
            cmd.append(value)
    cmd.append(url)
    return cmd

def _fetch_file(url, **kwargs):
    """Get a file and return the content"""
    params = {
        "silent": None,
        "location": None,
    }
    params.update(kwargs)
    return __salt__["cmd.run_stdout"](_curl_cmd(url, **params))

def _find_filesystem(device):
    """Use lsblk to find the filesystem of a partition."""
    cmd = ["lsblk", "--noheadings", "--output", "FSTYPE", device]
    return __salt__["cmd.run_stdout"](cmd)

def fetch_checksum(url, checksum_type, **kwargs):
    """
    Fecht the checksum from an image URL

url
        URL of the image. The protocol scheme needs to be available in
        curl. For example: http, https, scp, sftp, tftp or ftp.

The image can be compressed, and the supported extensions are:
        gz, bz2 and xz

checksum_type
        The type of checksum used to validate the image, possible
        values are 'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'.

Other paramaters send via kwargs will be used during the call for
    curl.

CLI Example:

.. code-block:: bash

salt '*' images.fetch_checksum https://my.url/JeOS.xz checksum_type=md5

"""

checksum_url = _checksum_url(url, checksum_type)
    checksum = _fetch_file(checksum_url, **kwargs)
    if not checksum:
        raise CommandExecutionError(
            "Checksum file not found in {}".format(checksum_url)
        )
    checksum = checksum.split()[0]
    LOG.info("Checksum for the image {}".format(checksum))
    return checksum

def dump(url, device, checksum_type=None, checksum=None, **kwargs):
    """Download an image and copy it into a device

url
        URL of the image. The protocol scheme needs to be available in
        curl. For example: http, https, scp, sftp, tftp or ftp.

The image can be compressed, and the supported extensions are:
        gz, bz2 and xz

device
        The device or partition where the image will be copied.

checksum_type
        The type of checksum used to validate the image, possible
        values are 'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'.

checksum
        The checksum value. If omitted but a `checksum_type` was set,
        it will try to download the checksum file from the same URL,
        replacing the extension with the `checksum_type`

Other paramaters send via kwargs will be used during the call for
    curl.

If succeed it will return the real checksum of the image. If
    checksum_type is not specified, MD5 will be used.

CLI Example:

.. code-block:: bash

salt '*' images.dump https://my.url/JeOS-btrfs.xz /dev/sda1
        salt '*' images.dump tftp://my.url/JeOS.xz /dev/sda1 checksum_type=md5

"""

scheme, _, path, *_ = urllib.parse.urlparse(url)
    if scheme not in VALID_SCHEME:
        raise SaltInvocationError("Protocol not valid for URL")

# We cannot validate the compression extension, as we can have
    # non-restricted file names, like '/my-image.ext3' or
    # 'other-image.raw'.

if checksum_type and checksum_type not in VALID_CHECKSUMS:
        raise SaltInvocationError("Checksum type not valid")

if not checksum_type and checksum:
        raise SaltInvocationError("Checksum type not provided")

if checksum_type and not checksum:
        checksum = fetch_checksum(url, checksum_type, **kwargs)

params = {
        "fail": None,
        "location": None,
        "silent": None,
    }
    params.update(kwargs)

# If any element in the pipe fail, exit early
    cmd = ["set -eo pipefail", ";"]
    cmd.extend(_curl_cmd(url, **params))

suffix = pathlib.Path(path).suffix[1:]
    if suffix in VALID_COMPRESSIONS:
        cmd.append("|")
        cmd.extend(
            {"gz": ["gunzip"], "bz2": ["bzip2", "-d"], "xz": ["xz", "-d"]}[suffix]
        )

checksum_prg = "{}sum".format(checksum_type) if checksum_type else "md5sum"
    cmd.extend(["|", "tee", device, "|", checksum_prg])
    ret = __salt__["cmd.run_all"](" ".join(cmd), python_shell=True)
    if ret["retcode"]:
        raise CommandExecutionError(
            "Error while fetching image {}: {}".format(url, ret["stderr"])
        )

new_checksum = ret["stdout"].split()[0]

if checksum_type and checksum != new_checksum:
        raise CommandExecutionError(
            "Checksum mismatch. "
            "Expected {}, calculated {}".format(checksum, new_checksum)
        )

filesystem = _find_filesystem(device)

resize_cmd = {
        "ext2": "e2fsck -f -y {0}; resize2fs {0}".format(device),
        "ext3": "e2fsck -f -y {0}; resize2fs {0}".format(device),
        "ext4": "e2fsck -f -y {0}; resize2fs {0}".format(device),
        "btrfs": "mount {} /mnt; btrfs filesystem resize max /mnt;"
        " umount /mnt".format(device),
        "xfs": "mount {} /mnt; xfs_growfs /mnt; umount /mnt".format(device),
    }
    if filesystem not in resize_cmd:
        raise CommandExecutionError(
            "Filesystem {} cannot be resized.".format(filesystem)
        )

ret = __salt__["cmd.run_all"](resize_cmd[filesystem], python_shell=True)
    if ret["retcode"]:
        raise CommandExecutionError(
            "Error while resizing the partition {}: {}".format(device, ret["stderr"])
        )

__salt__["cmd.run"]("sync")

return new_checksum
07070100000028000081A40000427000000032000000015F4E04F800002BAF000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_modules/partmod.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

from salt.exceptions import SaltInvocationError

import lp
import disk

LOG = logging.getLogger(__name__)

__virtualname__ = "partmod"

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __grains__
    __salt__
except NameError:
    __grains__ = {}
    __salt__ = {}

PENALIZATION = {
    # Penalization for wasted space remaining in the device
    "free": 1,
    # Default penalizations
    "minimum_recommendation_size": 5,
    "maximum_recommendation_size": 2,
    "decrement_current_partition_size": 10,
    "increment_current_partition_size": 10,
    # /
    "root_minimum_recommendation_size": 5,
    "root_maximum_recommendation_size": 2,
    "root_decrement_current_partition_size": 10,
    "root_increment_current_partition_size": 10,
    # /home
    "home_minimum_recommendation_size": 5,
    "home_maximum_recommendation_size": 2,
    "home_decrement_current_partition_size": 10,
    "home_increment_current_partition_size": 10,
    # /var
    "var_minimum_recommendation_size": 5,
    "var_maximum_recommendation_size": 2,
    "var_decrement_current_partition_size": 10,
    "var_increment_current_partition_size": 10,
}

FREE = "free"
MIN = "minimum_recommendation_size"
MAX = "maximum_recommendation_size"
INC = "decrement_current_partition_size"
DEC = "increment_current_partition_size"

# Default values for some partition parameters
LABEL = "msdos"
INITIAL_GAP = 0
UNITS = "MB"

VALID_PART_TYPE = ("swap", "linux", "boot", "efi", "lvm", "raid")

def _penalization(partition=None, section=FREE):
    """Penalization for a partition."""
    kind = "{}_{}".format(partition, section)
    if kind in PENALIZATION:
        return PENALIZATION[kind]
    return PENALIZATION[section]

def plan(name, constraints, unit="MB", export=False):
    """Analyze the current hardware and make a partition proposal.

name
        Name of the root element of the dictionary

constraints
        List of constraints for the partitions. Each element of the
        list will be a tuple with a name of partition, aminimum size
        (None if not required), and a maximum size (None if not
        required).

Example: "[['swap', null, null], ['home', 524288, null]]"

unit
        Unit where the sizes are expressed. Are the same valid units
        for the parted module

export
        Export the partition proposal as a grains under the given name

CLI Example:

.. code-block:: bash

salt '*' pplan.plan proposal "[['swap', null, null], ...]"

"""
    if not constraints:
        raise SaltInvocationError("contraints parameter is required")

hd_size = __salt__["status.diskusage"]("/dev/sda")["/dev/sda"]["total"]
    # TODO(aplanas) We only work on MB
    hd_size /= 1024

# TODO(aplanas) Fix the situation with swap.
    # Replace the None in the max position in the constraints with
    # hd_size.
    constraints = [(c[0], c[1], c[2] if c[2] else hd_size) for c in constraints]

# Generate the variables of our model:
    #   <part>_size, <part>_to_min_size, <part>_from_max_size
    variables = [
        "{}_{}".format(constraint[0], suffix)
        for constraint in constraints
        for suffix in ("size", "to_min_size", "from_max_size")
    ]
    model = lp.Model(variables)

for constraint in constraints:
        part_size = "{}_size".format(constraint[0])
        part_to_min_size = "{}_to_min_size".format(constraint[0])
        part_from_max_size = "{}_from_max_size".format(constraint[0])
        model_constraints = (
            # <part>_size >= MINIMUM_RECOMMENDATION_SIZE - <part>_to_min_size
            ({part_size: 1, part_to_min_size: 1}, lp.GTE, constraint[1]),
            # <part>_size <= MAXIMUM_RECOMMENDATION_SIZE + <part>_from_max_size
            ({part_size: 1, part_from_max_size: 1}, lp.LTE, constraint[2]),
        )
        for model_constraint in model_constraints:
            model.add_constraint_named(*model_constraint)

# sum(<part>_size) <= HD_SIZE
    model_constraint = (
        {"{}_size".format(c[0]): 1 for c in constraints},
        lp.LTE,
        hd_size,
    )
    model.add_constraint_named(*model_constraint)

# Minimize: PENALIZATION_FREE * (HD_SIZE - Sum(<part>_size))
    #   + PENALIZATION_MINIMUM_RECOMMENDATION_SIZE * <part>_to_min_size
    #   + PENALIZATION_MAXIMUM_RECOMMENDATIOM_SIZE * <part>_from_max_size
    coefficients = {
        "{}_{}".format(constraint[0], suffix): _penalization(
            partition=constraint[0],
            section={"to_min_size": MIN, "from_max_size": MAX}[suffix],
        )
        for constraint in constraints
        for suffix in ("to_min_size", "from_max_size")
    }
    coefficients.update(
        {
            "{}_size".format(constraint[0]): -_penalization(section=FREE)
            for constraint in constraints
        }
    )
    model.add_cost_function_named(
        lp.MINIMIZE, coefficients, _penalization(section=FREE) * hd_size
    )

plan = {name: model.simplex()}
    if export:
        __salt__["grains.setvals"](plan)

return plan

def prepare_partition_data(partitions):
    """Helper function to prepare the patition data from the pillar."""

# Validate and normalize the `partitions` pillar. The state will
    # expect a dictionary with this schema:
    #
    # partitions_normalized = {
    #     '/dev/sda': {
    #         'label': 'gpt',
    #         'pmbr_boot': False,
    #         'partitions': [
    #             {
    #                 'part_id': '/dev/sda1',
    #                 'part_type': 'primary'
    #                 'fs_type': 'ext2',
    #                 'flags': ['esp'],
    #                 'start': '0MB',
    #                 'end': '100%',
    #             },
    #         ],
    #     },
    # }

is_uefi = __grains__["efi"]

# Get the fallback values for label and initial_gap
    config = partitions.get("config", {})
    global_label = config.get("label", LABEL)
    global_initial_gap = config.get("initial_gap", INITIAL_GAP)

partitions_normalized = {}
    for device, device_info in partitions["devices"].items():
        label = device_info.get("label", global_label)
        initial_gap = device_info.get("initial_gap", global_initial_gap)
        if initial_gap:
            initial_gap_num, units = disk.units(initial_gap, default=None)
        else:
            initial_gap_num, units = 0, None

device_normalized = {
            "label": label,
            "pmbr_boot": label == "gpt" and not is_uefi,
            "partitions": [],
        }
        partitions_normalized[device] = device_normalized

# Control the start of the next partition
        start_size = initial_gap_num
        # Flag to detect if `rest` size was used before
        rest = False

for index, partition in enumerate(device_info.get("partitions", [])):
            # Detect if there is another partition after we create one
            # that complete the free space
            if rest:
                raise SaltInvocationError(
                    "Partition defined after one filled all the rest free "
                    "space. Use `rest` only on the last partition."
                )

# Validate the partition type
            part_type = partition.get("type")
            if part_type not in VALID_PART_TYPE:
                raise SaltInvocationError(
                    "Partition type {} not recognized".format(part_type)
                )

# If part_id is not given, we can create a partition name
            # based on the position of the partition and the name of
            # the device
            #
            # TODO(aplanas) The partition number will be deduced, so
            # the require section in mkfs_partition will fail
            part_id = "{}{}{}".format(
                device,
                "p" if __salt__["filters.is_raid"](device) else "",
                partitions.get("number", index + 1),
            )
            part_id = partition.get("id", part_id)

# For parted we usually need to set a ext2 filesystem
            # type, except for SWAP or UEFI
            fs_type = {"swap": "linux-swap", "efi": "fat16"}.get(part_type, "ext2")

# Check if we are changing units inside the device
            if partition["size"] == "rest":
                rest = True
                # If units is not set, we default to '%'
                units = units or "%"
                start = "{}{}".format(start_size, units)
                end = "100%"
            else:
                size, size_units = disk.units(partition["size"])
                if units and size_units and units != size_units:
                    raise SaltInvocationError(
                        "Units needs to be the same for the partitions inside "
                        "a device. Found {} but expected {}. Note that "
                        "`initial_gap` is also considered.".format(size_units, units)
                    )
                # If units and size_units is not set, we default to UNITS
                units = units or size_units or UNITS
                start = "{}{}".format(start_size, units)
                end = "{}{}".format(start_size + size, units)
                start_size += size

flags = None
            if part_type in ("raid", "lvm"):
                flags = [part_type]
            elif part_type == "boot" and label == "gpt" and not is_uefi:
                flags = ["bios_grub"]
            elif part_type == "efi" and label == "gpt" and is_uefi:
                flags = ["esp"]

device_normalized["partitions"].append(
                {
                    "part_id": part_id,
                    # TODO(aplanas) If msdos we need to create extended
                    # and logical
                    "part_type": "primary",
                    "fs_type": fs_type,
                    "start": start,
                    "end": end,
                    "flags": flags,
                }
            )

return partitions_normalized
07070100000029000081A40000427000000032000000015F4E04F800001C35000000000000000000000000000000000000003F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_modules/suseconnect.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import salt.utils.path
from salt.exceptions import CommandExecutionError

LOG = logging.getLogger(__name__)

__virtualname__ = "suseconnect"

def __virtual__():
    """
    Only load the module if SUSEConnect is installed
    """
    if not salt.utils.path.which("SUSEConnect"):
        return (False, "SUSEConnect is not installed.")
    return __virtualname__

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __salt__
except NameError:
    __salt__ = {}

def _cmd(cmd):
    """Utility function to run commands."""
    result = __salt__["cmd.run_all"](cmd)
    if result["retcode"]:
        raise CommandExecutionError(result["stdout"] + result["stderr"])
    return result["stdout"]

def register(regcode, product=None, email=None, url=None, root=None):
    """
    .. versionadded:: TBD

regcode
       Subscription registration code for the product to be
       registered. Relates that product to the specified subscription,
       and enalbes software repositories for that product.

product
       Specify a product for activation/deactivation. Only one product
       can be processed at a time. Defaults to the base SUSE Linux
       Enterprose product on this system.
       Format: <name>/<version>/<architecture>

email
       Email address for product registration

url
       URL for the registration server (will be saved for the next
       use) (e.g. https://scc.suse.com)

root
       Path to the root folder, uses the same parameter for zypper

CLI Example:

.. code-block:: bash

salt '*' suseconnect.register xxxx-yyy-zzzz
       salt '*' suseconnect.register xxxx-yyy-zzzz product='sle-ha/15.2/x86_64'

"""
    cmd = ["SUSEConnect", "--regcode", regcode]

parameters = [("product", product), ("email", email), ("url", url), ("root", root)]

for parameter, value in parameters:
        if value:
            cmd.extend(["--{}".format(parameter), str(value)])

return _cmd(cmd)

def deregister(product=None, url=None, root=None):
    """
    .. versionadded:: TBD

De-register the system and base product, or in cojuntion with
    'product', a single extension, and removes all its services
    installed by SUSEConnect. After de-registration the system no
    longer consumes a subscription slot in SCC.

url
       URL for the registration server (will be saved for the next
       use) (e.g. https://scc.suse.com)

root
       Path to the root folder, uses the same parameter for zypper

CLI Example:

.. code-block:: bash

salt '*' suseconnect.deregister
       salt '*' suseconnect.deregister product='sle-ha/15.2/x86_64'

"""
    cmd = ["SUSEConnect", "--de-register"]

parameters = [("product", product), ("url", url), ("root", root)]

for parameter, value in parameters:
        if value:
            cmd.extend(["--{}".format(parameter), str(value)])

return _cmd(cmd)

def status(root=None):
    """
    .. versionadded:: TBD

Get current system registation status.

root
       Path to the root folder, uses the same parameter for zypper

CLI Example:

.. code-block:: bash

salt '*' suseconnect.status

"""
    cmd = ["SUSEConnect", "--status"]

parameters = [("root", root)]

for parameter, value in parameters:
        if value:
            cmd.extend(["--{}".format(parameter), str(value)])

return json.loads(_cmd(cmd))

def _parse_list_extensions(output):
    """Parse the output of list-extensions result"""
    # We can extract the indentation using this regex:
    #   r'( {4,}).*\s([-\w]+/[-\w\.]+/[-\w]+).*'
    return re.findall(r"\s([-\w]+/[-\w\.]+/[-\w]+)", output)

def list_extensions(url=None, root=None):
    """
    .. versionadded:: TBD

List all extensions and modules avaiable for installation on this
    system.

url
       URL for the registration server (will be saved for the next
       use) (e.g. https://scc.suse.com)

root
       Path to the root folder, uses the same parameter for zypper

CLI Example:

.. code-block:: bash

salt '*' suseconnect.list-extensions
       salt '*' suseconnect.list-extensions url=https://scc.suse.com

"""
    cmd = ["SUSEConnect", "--list-extensions"]

parameters = [("url", url), ("root", root)]

for parameter, value in parameters:
        if value:
            cmd.extend(["--{}".format(parameter), str(value)])

# TODO(aplanas) Implement a better parser
    return _parse_list_extensions(_cmd(cmd))

def cleanup(root=None):
    """
    .. versionadded:: TBD

Remove olf system credential and all zypper services installed by
    SUSEConnect

root
       Path to the root folder, uses the same parameter for zypper

CLI Example:

.. code-block:: bash

salt '*' suseconnect.cleanup

"""
    cmd = ["SUSEConnect", "--cleanup"]

parameters = [("root", root)]

for parameter, value in parameters:
        if value:
            cmd.extend(["--{}".format(parameter), str(value)])

return _cmd(cmd)

def rollback(url=None, root=None):
    """
    .. versionadded:: TBD

Revert the registration state in case of a failed migration.

url
       URL for the registration server (will be saved for the next
       use) (e.g. https://scc.suse.com)

root
       Path to the root folder, uses the same parameter for zypper

CLI Example:

.. code-block:: bash

salt '*' suseconnect.rollback
       salt '*' suseconnect.rollback url=https://scc.suse.com

"""
    cmd = ["SUSEConnect", "--rollback"]

parameters = [("url", url), ("root", root)]

for parameter, value in parameters:
        if value:
            cmd.extend(["--{}".format(parameter), str(value)])

return _cmd(cmd)
0707010000002A000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000002F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_states0707010000002B000081A40000427000000032000000015F4E04F800000E8D000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_states/formatted.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

LOG = logging.getLogger(__name__)

__virtualname__ = "formatted"

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __opts__
    __salt__
    __states__
except NameError:
    __opts__ = {}
    __salt__ = {}
    __states__ = {}

def __virtual__():
    """
    Formatted can be considered as an extension to blockdev

"""
    return "blockdev.formatted" in __states__

def formatted(name, fs_type="ext4", force=False, **kwargs):
    """
    Manage filesystems of partitions.

name
        The name of the block device

fs_type
        The filesystem it should be formatted as

force
        Force mke2fs to create a filesystem, even if the specified
        device is not a partition on a block special device. This
        option is only enabled for ext and xfs filesystems

This option is dangerous, use it with caution.

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

fs_type = "swap" if fs_type == "linux-swap" else fs_type
    if fs_type != "swap":
        ret = __states__["blockdev.formatted"](name, fs_type, force, **kwargs)
        return ret

if not os.path.exists(name):
        ret["comment"].append("{} does not exist".format(name))
        return ret

current_fs = _checkblk(name)

if current_fs == "swap":
        ret["result"] = True
        return ret
    elif __opts__["test"]:
        ret["comment"].append("Changes to {} will be applied ".format(name))
        ret["result"] = None
        return ret

cmd = ["mkswap"]
    if force:
        cmd.append("-f")
    if kwargs.pop("check", False):
        cmd.append("-c")
    for parameter, argument in (
        ("-p", "pagesize"),
        ("-L", "label"),
        ("-v", "swapversion"),
        ("-U", "uuid"),
    ):
        if argument in kwargs:
            cmd.extend([parameter, kwargs.pop(argument)])
    cmd.append(name)

__salt__["cmd.run"](cmd)

current_fs = _checkblk(name)

if current_fs == "swap":
        ret["comment"].append(
            ("{} has been formatted with {}").format(name, fs_type)
        )
        ret["changes"] = {"new": fs_type, "old": current_fs}
        ret["result"] = True
    else:
        ret["comment"].append("Failed to format {}".format(name))
        ret["result"] = False
    return ret

def _checkblk(name):
    """
    Check if the blk exists and return its fstype if ok
    """

blk = __salt__["cmd.run"](
        "blkid -o value -s TYPE {0}".format(name), ignore_retcode=True
    )
    return "" if not blk else blk
0707010000002C000081A40000427000000032000000015F4E04F800001A72000000000000000000000000000000000000003900000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_states/images.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

LOG = logging.getLogger(__name__)

__virtualname__ = "images"

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __opts__
    __salt__
    __utils__
except NameError:
    __opts__ = {}
    __salt__ = {}
    __utils__ = {}

# Copied from `images` execution module, as we cannot easly import it
VALID_SCHEME = (
    "dict",
    "file",
    "ftp",
    "ftps",
    "gopher",
    "http",
    "https",
    "imap",
    "imaps",
    "ldap",
    "ldaps",
    "pop3",
    "pop3s",
    "rtmp",
    "rtsp",
    "scp",
    "sftp",
    "smb",
    "smbs",
    "smtp",
    "smtps",
    "telnet",
    "tftp",
)
VALID_COMPRESSIONS = ("gz", "bz2", "xz")
VALID_CHECKSUMS = ("md5", "sha1", "sha224", "sha256", "sha384", "sha512")

def __virtual__():
    """Images depends on images.dump module"""
    return "images.dump" in __salt__

def _mount(device):
    """Mount the device in a temporary place"""
    dest = tempfile.mkdtemp()
    res = __salt__["mount.mount"](name=dest, device=device)
    if res is not True:
        return None
    return dest

def _umount(path):
    """Umount and clean the temporary place"""
    __salt__["mount.umount"](path)
    __utils__["files.rm_rf"](path)

def _checksum_path(root):
    """Return the path where we will store the last checksum"""
    return os.path.join(root, __opts__["cachedir"][1:], "images")

def _read_current_checksum(device, checksum_type):
    """Return the checksum of the current image, if any"""
    checksum = None
    mnt = _mount(device)
    if not mnt:
        return None

checksum_file = os.path.join(
        _checksum_path(mnt), "checksum.{}".format(checksum_type)
    )
    try:
        checksum = open(checksum_file).read()
        LOG.info("Checksum file %s content: %s", checksum_file, checksum)
    except Exception:
        # If the file cannot be read, we expect that the image needs
        # to be re-applied eventually
        LOG.info("Checksum file %s not found", checksum_file)

_umount(mnt)
    return checksum

def _save_current_checksum(device, checksum_type, checksum):
    """Save the checksum of the current image"""
    result = False
    mnt = _mount(device)
    if not mnt:
        return result

checksum_path = _checksum_path(mnt)
    os.makedirs(checksum_path, exist_ok=True)
    checksum_file = os.path.join(checksum_path, "checksum.{}".format(checksum_type))
    try:
        checksum_file = open(checksum_file, "w")
        checksum_file.write(checksum)
        checksum_file.close()
        result = True
        LOG.info("Created checksum file %s content: %s", checksum_file, checksum)
    except Exception:
        LOG.error("Error writing checksum file %s", checksum_file)

_umount(mnt)
    return result

def _is_dump_needed(device, checksum_type, checksum):
    return True

def dumped(name, device, checksum_type=None, checksum=None, **kwargs):
    """
    Copy an image in the device.

name
        URL of the image. The protocol scheme needs to be available in
        curl. For example: http, https, scp, sftp, tftp or ftp.

The image can be compressed, and the supported extensions are:
        gz, bz2 and xz

device
        The device or partition where the image will be copied.

checksum_type
        The type of checksum used to validate the image, possible
        values are 'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512'.

Other paramaters send via kwargs will be used during the call for
    curl.

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

scheme, _, path, *_ = urllib.parse.urlparse(name)
    if scheme not in VALID_SCHEME:
        ret["comment"].append("Protocol not valid for URL")
        return ret

# We cannot validate the compression extension, as we can have
    # non-restricted file names, like '/my-image.ext3' or
    # 'other-image.raw'.

if checksum_type and checksum_type not in VALID_CHECKSUMS:
        ret["comment"].append("Checksum type not valid")
        return ret

if not checksum_type and checksum:
        ret["comment"].append("Checksum type not provided")
        return ret

if checksum_type and not checksum:
        checksum = __salt__["images.fetch_checksum"](name, checksum_type, **kwargs)
        if not checksum:
            ret["comment"].append("Checksum no found")
            return ret

if checksum_type:
        current_checksum = _read_current_checksum(device, checksum_type)

if __opts__["test"]:
        ret["result"] = None
        if checksum_type:
            ret["changes"]["image"] = current_checksum != checksum
            ret["changes"]["checksum cache"] = ret["changes"]["image"]
        return ret

if checksum_type and current_checksum != checksum:
        result = __salt__["images.dump"](
            name, device, checksum_type, checksum, **kwargs
        )
        if result != checksum:
            ret["comment"].append("Failed writing the image")
            return ret
        else:
            ret["changes"]["image"] = True

saved = _save_current_checksum(device, checksum_type, checksum)
        if not saved:
            ret["comment"].append("Checksum failed to be saved in the cache")
            return ret
        else:
            ret["changes"]["checksum cache"] = True

ret["result"] = True
    return ret
0707010000002D000081A40000427000000032000000015F4E04F800005AF4000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_states/partitioned.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

from salt.exceptions import CommandExecutionError

import disk

log = logging.getLogger(__name__)

__virtualname__ = "partitioned"

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __grains__
    __opts__
    __salt__
except NameError:
    __grains__ = {}
    __opts__ = {}
    __salt__ = {}

class EnumerateException(Exception):
    pass

def __virtual__():
    """
    Partitioned depends on partition.mkpart module

"""

return "partition.mkpart" in __salt__

def _check_label(device, label):
    """
    Check if the label match with the device

"""
    label = {"dos": "msdos"}.get(label, label)
    res = __salt__["cmd.run"](["parted", "-l", device])
    return "partition table: {}".format(label) in res.lower()

def labeled(name, label):
    """
    Make sure that the label of the partition is properly set.

name
        Device name (/dev/sda, /dev/disk/by-id/scsi-...)

label
        Label of the partition (usually 'gpt' or 'msdos')

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if not label:
        ret["comment"].append("Label parameter is not optional")
        return ret

if _check_label(name, label):
        ret["result"] = True
        ret["comment"].append("Label already set to {}".format(label))
        return ret

if __opts__["test"]:
        ret["result"] = None
        ret["comment"].append("Label will be set to {} in {}".format(label, name))
        ret["changes"]["label"] = "Will be set to {}".format(label)
        return ret

__salt__["partition.mklabel"](name, label)

if _check_label(name, label):
        ret["result"] = True
        msg = "Label set to {} in {}".format(label, name)
        ret["comment"].append(msg)
        ret["changes"]["label"] = msg
    else:
        ret["comment"].append("Failed to set label to {}".format(label))

return ret

def _get_partition_type(device):
    """
    Get partition type of each partition

Return dictionary: {number: type, ...}

"""
    cmd = "parted -s {0} print".format(device)
    out = __salt__["cmd.run_stdout"](cmd)
    types = re.findall(r"\s*(\d+).*(primary|extended|logical).*", out)
    return dict(types)

def _get_cached_info(device):
    """
    Get the information of a device as a dictionary

"""
    if not hasattr(_get_cached_info, "info"):
        _get_cached_info.info = {}
    info = _get_cached_info.info

if device not in info:
        info[device] = __salt__["partition.list"](device)["info"]
    return info[device]

def _invalidate_cached_info():
    """
    Invalidate the cached information about devices

"""
    if hasattr(_get_cached_info, "info"):
        delattr(_get_cached_info, "info")

def _get_cached_partitions(device, unit="s"):
    """
    Get the partitions as a dictionary

"""
    # `partitions` will be used as a local cache, to avoid multiple
    # request of the same partition with the same units. Is a
    # dictionary where the key is the `unit`, as we will make request
    # of all partitions under this unit. This potentially can low the
    # complexity algorithm to amortized O(1).
    if not hasattr(_get_cached_partitions, "partitions"):
        _get_cached_partitions.partitions = {}
        # There is a bug in `partition.list`, where `type` is storing
        # the file system information, to workaround this we get the
        # partition type using parted and attach it here.
        _get_cached_partitions.types = _get_partition_type(device)

if device not in _get_cached_partitions.partitions:
        _get_cached_partitions.partitions[device] = {}
    partitions = _get_cached_partitions.partitions[device]

if unit not in partitions:
        partitions[unit] = __salt__["partition.list"](device, unit=unit)
        # If the partition comes from a gpt disk, we assign the type
        # as 'primary'
        types = _get_cached_partitions.types
        for number, partition in partitions[unit]["partitions"].items():
            partition["type"] = types.get(number, "primary")

return partitions[unit]["partitions"]

def _invalidate_cached_partitions():
    """
    Invalidate the cached information about partitions

"""
    if hasattr(_get_cached_partitions, "partitions"):
        delattr(_get_cached_partitions, "partitions")
        delattr(_get_cached_partitions, "types")

OVERLAPPING_ERROR = 0.75

def _check_partition(device, number, part_type, start, end):
    """
    Check if the proposed partition match the current one.

Returns a tri-state value:
      - `True`: the proposed partition match
      - `False`: the proposed partition do not match
      - `None`: the proposed partition is a new partition
    """
    # The `start` and `end` fields are expressed with units (the same
    # kind of units that `parted` allows). To make a fair comparison
    # we need to normalize each field to the same units that we can
    # use to read the current partitions. A good candidate is sector
    # ('s'). The problem is that we need to reimplement the same
    # conversion logic from `parted` here [1], as we need the same
    # round logic when we convert from 'MiB' to 's', for example.
    #
    # To avoid this duplicity of code we can do a trick: for each
    # field in the proposed partition we request a `partition.list`
    # with the same unit. We make `parted` to make the conversion for
    # us, in exchange for an slower algorithm.
    #
    # We can change it once we decide to take care of alignment.
    #
    # [1] Check libparted/unit.c

number = str(number)
    partitions = _get_cached_partitions(device)
    if number not in partitions:
        return None

if part_type != partitions[number]["type"]:
        return False

for value, name in ((start, "start"), (end, "end")):
        value, unit = disk.units(value)
        p_value = _get_cached_partitions(device, unit)[number][name]
        p_value = disk.units(p_value)[0]
        min_value = value - OVERLAPPING_ERROR
        max_value = value + OVERLAPPING_ERROR
        if not min_value <= p_value <= max_value:
            return False

return True

def _get_first_overlapping_partition(device, start):
    """
    Return the first partition that contains the start point.

"""
    # Check if there is a partition in the system that start at
    # specified point.
    value, unit = disk.units(start)
    value += OVERLAPPING_ERROR

partitions = _get_cached_partitions(device, unit)
    partition_number = None
    partition_start = 0
    for number, partition in partitions.items():
        p_start = disk.units(partition["start"])[0]
        p_end = disk.units(partition["end"])[0]
        if p_start <= value <= p_end:
            if partition_number is None or partition_start < p_start:
                partition_number = number
                partition_start = p_start
    return partition_number

def _get_partition_number(device, part_type, start, end):
    """
    Return a partition number for a [start, end] range and a partition
    type.

If the range is allocated and the partition type match, return the
    partition number. If the type do not match but is a logical
    partition inside an extended one, return the next partition
    number.

If the range is not allocated, return the next partition number.

"""

unit = disk.units(start)[1]
    partitions = _get_cached_partitions(device, unit)

# Check if there is a partition in the system that start or
    # containst the start point
    number = _get_first_overlapping_partition(device, start)
    if number:
        if partitions[number]["type"] == part_type:
            return number
        elif not (partitions[number]["type"] == "extended" and part_type == "logical"):
            raise EnumerateException("Do not overlap partitions")

def __primary_partition_free_slot(partitions, label):
        if label == "msdos":
            max_primary = 4
        else:
            max_primary = 1024
        for i in range(1, max_primary + 1):
            i = str(i)
            if i not in partitions:
                return i

# The partition is not already there, we guess the next number
    label = _get_cached_info(device)["partition table"]
    if part_type == "primary":
        candidate = __primary_partition_free_slot(partitions, label)
        if not candidate:
            raise EnumerateException("No free slot for primary partition")
        return candidate
    elif part_type == "extended":
        if label == "gpt":
            raise EnumerateException("Extended partitions not allowed in gpt")
        if "extended" in (info["type"] for info in partitions.values()):
            raise EnumerateException("Already found a extended partition")
        candidate = __primary_partition_free_slot(partitions, label)
        if not candidate:
            raise EnumerateException("No free slot for extended partition")
        return candidate
    elif part_type == "logical":
        if label == "gpt":
            raise EnumerateException("Extended partitions not allowed in gpt")
        if "extended" not in (part["type"] for part in partitions.values()):
            raise EnumerateException("Missing extended partition")
        candidate = max(
            (
                int(part["number"])
                for part in partitions.values()
                if part["type"] == "logical"
            ),
            default=4,
        )
        return str(candidate + 1)

def _get_partition_flags(device, number):
    """
    Return the current list of flags for a partition.
    """

def _is_valid(flag):
        """Return True if is a valid flag"""
        if flag == "swap" or flag.startswith("type="):
            return False
        return True

result = []
    number = str(number)
    partitions = __salt__["partition.list"](device)["partitions"]
    if number in partitions:
        # In parted the field for flags is reused to mark other
        # situations, so we need to remove values that do not
        # represent flags
        flags = partitions[number]["flags"].split(", ")
        result = [flag for flag in flags if flag and _is_valid(flag)]
    return result

def mkparted(name, part_type, fs_type=None, start=None, end=None, flags=None):
    """
    Make sure that a partition is allocated in the disk.

name
        Device or partition name. If the name is like /dev/sda, parted
        will take care of creating the partition on the next slot. If
        the name is like /dev/sda1, we will consider partition 1 as a
        reference for the match.

part_type
        Type of partition, should be one of "primary", "logical", or
        "extended".

fs_type
        Expected filesystem, following the parted names.

start
        Start of the partition (in parted units)

end
        End of the partition (in parted units)

flags
        List of flags present in the partition

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if part_type not in ("primary", "extended", "logical"):
        ret["comment"].append("Partition type not recognized")
    if not start or not end:
        ret["comment"].append("Parameters start and end are not optional")

# Normalize fs_type. Some versions of salt contains a bug were
    # only a subset of file systems are valid for mkpart, even if are
    # supported by parted. As mkpart do not format the partition, is
    # safe to make a normalization here. Eventually this is only used
    # to set the type in the flag section (partition id).
    #
    # We can drop this check in the next version of salt.
    if fs_type and fs_type not in set(
        [
            "ext2",
            "fat32",
            "fat16",
            "linux-swap",
            "reiserfs",
            "hfs",
            "hfs+",
            "hfsx",
            "NTFS",
            "ufs",
            "xfs",
            "zfs",
        ]
    ):
        fs_type = "ext2"

flags = flags if flags else []

# If the user do not provide any partition number we get generate
    # the next available for the partition type
    device_md, device_no_md, number = re.search(
        r"(?:(/dev/md[^p]+)p?|(\D+))(\d*)", name
    ).groups()
    device = device_md if device_md else device_no_md
    if not number:
        try:
            number = _get_partition_number(device, part_type, start, end)
        except EnumerateException as e:
            ret["comment"].append(str(e))

# If at this point we have some comments, we return with a fail
    if ret["comment"]:
        return ret

# Check if the partition is already there or we need to create a
    # new one
    partition_match = _check_partition(device, number, part_type, start, end)

if partition_match:
        ret["result"] = True
        ret["comment"].append(
            "Partition {}{} already in place".format(device, number)
        )
        return ret
    elif partition_match is None:
        ret["changes"]["new"] = "Partition {}{} will be created".format(
            device, number
        )
    elif partition_match is False:
        ret["comment"].append(
            "Partition {}{} cannot be replaced".format(device, number)
        )
        return ret

if __opts__["test"]:
        ret["result"] = None
        return ret

if partition_match is None:
        # TODO(aplanas) with parted we cannot force a partition number
        res = __salt__["partition.mkpart"](device, part_type, fs_type, start, end)
        ret["changes"]["output"] = res

# Wipe the filesystem information from the partition to remove
        # old data that was on the disk.  As a side effect, this will
        # force the mkfs state to happend.
        __salt__["disk.wipe"]("{}{}".format(device, number))

_invalidate_cached_info()
        _invalidate_cached_partitions()

# The first time that we create a partition we do not have a
    # partition number for it
    if not number:
        number = _get_partition_number(device, part_type, start, end)

partition_match = _check_partition(device, number, part_type, start, end)
    if partition_match:
        ret["result"] = True
    elif not partition_match:
        ret["comment"].append(
            "Partition {}{} fail to be created".format(device, number)
        )
        ret["result"] = False

# We set the correct flags for the partition
    current_flags = _get_partition_flags(device, number)
    flags_to_set = set(flags) - set(current_flags)
    flags_to_unset = set(current_flags) - set(flags)

for flag in flags_to_set:
        try:
            out = __salt__["partition.set"](device, number, flag, "on")
        except CommandExecutionError as e:
            out = e
        if out:
            ret["comment"].append(
                "Error setting flag {} in {}{}: {}".format(flag, device, number, out)
            )
            ret["result"] = False
        else:
            ret["changes"][flag] = True

for flag in flags_to_unset:
        try:
            out = __salt__["partition.set"](device, number, flag, "off")
        except CommandExecutionError as e:
            out = e
        if out:
            ret["comment"].append(
                "Error unsetting flag {} in {}{}: {}".format(flag, device, number, out)
            )
            ret["result"] = False
        else:
            ret["changes"][flag] = False

return ret

def _check_partition_name(device, number, name):
    """
    Check if the partition have this name.

Returns a tri-state value:
      - `True`: the partition already have this label
      - `False`: the partition do not have this label
      - `None`: there is not such partition
    """
    number = str(number)
    partitions = _get_cached_partitions(device)
    if number in partitions:
        return partitions[number]["name"] == name

def named(name, device, partition=None):
    """
    Make sure that a gpt partition have set a name.

name
        Name or label for the partition

device
        Device name (/dev/sda, /dev/disk/by-id/scsi-...) or partition

partition
        Partition number (can be in the device)

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if not partition:
        device, partition = re.search(r"(\D+)(\d*)", device).groups()
    if not partition:
        ret["comment"].append("Partition number not provided")

if not _check_label(device, "gpt"):
        ret["comment"].append("Only gpt partitions can be named")

name_match = _check_partition_name(device, partition, name)
    if name_match:
        ret["result"] = True
        ret["comment"].append(
            "Name of the partition {}{} is "
            'already "{}"'.format(device, partition, name)
        )
    elif name_match is None:
        ret["comment"].append("Partition {}{} not found".format(device, partition))

if ret["comment"]:
        return ret

if __opts__["test"]:
        ret["comment"].append(
            "Partition {}{} will be named " '"{}"'.format(device, partition, name)
        )
        ret["changes"]["name"] = "Name will be set to {}".format(name)
        return ret

changes = __salt__["partition.name"](device, partition, name)
    _invalidate_cached_info()
    _invalidate_cached_partitions()

if _check_partition_name(device, partition, name):
        ret["result"] = True
        ret["comment"].append("Name set to {} in {}{}".format(name, device, partition))
        ret["changes"]["name"] = changes
    else:
        ret["comment"].append("Failed to set name to {}".format(name))

return ret

def _check_disk_flags(device, flag):
    """
    Return True if the flag for a device is already set.
    """
    flags = __salt__["partition.list"](device)["info"]["disk flags"]
    return flag in flags

def disk_set(name, flag, enabled=True):
    """
    Make sure that a disk flag is set or unset.

name
        Device name (/dev/sda, /dev/disk/by-id/scsi-...)

flag
        A valid parted disk flag (see ``parted.disk_set``)

enabled
        Boolean value

CLI Example:

.. code-block:: bash

salt '*' partitioned.disk_set /dev/sda pmbr_boot
        salt '*' partitioned.disk_set /dev/sda pmbr_boot False

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

is_flag = _check_disk_flags(name, flag)
    if enabled == is_flag:
        ret["result"] = True
        ret["comment"].append(
            "Flag {} in {} already {}".format(flag, name, "set" if enabled else "unset")
        )
        return ret

if __opts__["test"]:
        ret["comment"].append(
            "Flag {} in {} will be {}".format(flag, name, "set" if enabled else "unset")
        )
        ret["changes"][flag] = enabled
        return ret

__salt__["partition.disk_set"](name, flag, "on" if enabled else "off")

is_flag = _check_disk_flags(name, flag)
    if enabled == is_flag:
        ret["result"] = True
        ret["comment"].append(
            "Flag {} {} in {}".format(flag, "set" if enabled else "unset", name)
        )
        ret["changes"][flag] = enabled
    else:
        ret["comment"].append(
            "Failed to {} {} in {}".format("set" if enabled else "unset", flag, name)
        )

return ret

def _check_partition_flags(device, number, flag):
    """
    Return True if the flag for a partition is already set.

Returns a tri-state value:
      - `True`: the partition already have this flag
      - `False`: the partition do not have this flag
      - `None`: there is not such partition
    """
    number = str(number)
    partitions = __salt__["partition.list"](device)["partitions"]
    if number in partitions:
        return flag in partitions[number]["flags"]

def partition_set(name, flag, partition=None, enabled=True):
    """
    Make sure that a partition flag is set or unset.

name
        Device name (/dev/sda, /dev/disk/by-id/scsi-...) or partition

flag
        A valid parted disk flag (see ``parted.disk_set``)

partition
        Partition number (can be in the device name)

enabled
        Boolean value

CLI Example:

.. code-block:: bash

salt '*' partitioned.partition_set /dev/sda1 bios_grub
        salt '*' partitioned.partition_set /dev/sda bios_grub 1 False

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if not partition:
        name, partition = re.search(r"(\D+)(\d*)", name).groups()
    if not partition:
        ret["comment"].append("Partition number not provided")

is_flag = _check_partition_flags(name, partition, flag)
    if enabled == is_flag:
        ret["result"] = True
        ret["comment"].append(
            "Flag {} in {}{} already {}".format(
                flag, name, partition, "set" if enabled else "unset"
            )
        )
    elif is_flag is None:
        ret["comment"].append("Partition {}{} not found".format(name, partition))

if ret["comment"]:
        return ret

if __opts__["test"]:
        ret["comment"].append(
            "Flag {} in {}{} will be {}".format(
                flag, name, partition, "set" if enabled else "unset"
            )
        )
        ret["changes"][flag] = enabled
        return ret

__salt__["partition.set"](name, partition, flag, "on" if enabled else "off")

is_flag = _check_partition_flags(name, partition, flag)
    if enabled == is_flag:
        ret["result"] = True
        ret["comment"].append(
            "Flag {} {} in {}{}".format(
                flag, "set" if enabled else "unset", name, partition
            )
        )
        ret["changes"][flag] = enabled
    else:
        ret["comment"].append(
            "Failed to {} {} in {}{}".format(
                "set" if enabled else "unset", flag, name, partition
            )
        )
    return ret
0707010000002E000081A40000427000000032000000015F4E04F80000284A000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_states/snapper_install.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

log = logging.getLogger(__name__)

INSTALLATION_HELPER = "/usr/lib/snapper/installation-helper"
SNAPPER = "/usr/bin/snapper"

__virtualname__ = "snapper_install"

# Define not exported variables from Salt, so this can be imported as
# a normal module
try:
    __grains__
    __opts__
    __salt__
    __utils__
except NameError:
    __grains__ = {}
    __opts__ = {}
    __salt__ = {}
    __utils__ = {}

def __virtual__():
    """
    snapper_install requires the installation helper binary.

"""
    if not os.path.exists(INSTALLATION_HELPER):
        return (False, "{} binary not found".format(INSTALLATION_HELPER))
    return True

def _mount(device):
    """
    Mount the device in a temporary place.
    """
    dest = tempfile.mkdtemp()
    res = __salt__["mount.mount"](name=dest, device=device)
    if res is not True:
        log.error("Cannot mount device %s in %s", device, dest)
        _umount(dest)
        return None
    return dest

def _umount(path):
    """
    Umount and clean the temporary place.
    """
    __salt__["mount.umount"](path)
    __utils__["files.rm_rf"](path)

def __mount_device(action):
    """
    Small decorator to makes sure that the mount and umount happends in
    a transactional way.
    """

@functools.wraps(action)
    def wrapper(*args, **kwargs):
        device = kwargs.get("device", args[1] if len(args) > 1 else None)

ret = {
            "name": device,
            "result": False,
            "changes": {},
            "comment": ["Some error happends during the operation."],
        }
        try:
            dest = _mount(device)
            if not dest:
                msg = "Device {} cannot be mounted".format(device)
                ret["comment"].append(msg)
            kwargs["__dest"] = dest
            ret = action(*args, **kwargs)
        except Exception as e:
            log.error("""Traceback: {}""".format(traceback.format_exc()))
            ret["comment"].append(e)
        finally:
            _umount(dest)
        return ret

return wrapper

def step_one(name, device, description):
    """
    Step one of the installation-helper tool

name
        Name of the state

device
        Device where to install snapper

description
        Description for the fist snapshot

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

# Mount the device and check if /etc/snapper/configs is present
    dest = _mount(device)
    if not dest:
        ret["comment"].append(
            "Fail mounting {} in temporal directory {}".format(device, dest)
        )
        return ret

is_configs = os.path.exists(os.path.join(dest, "etc/snapper/configs"))
    _umount(dest)

if is_configs:
        ret["result"] = None if __opts__["test"] else True
        ret["comment"].append("Step one already applied to {}".format(device))
        return ret

if __opts__["test"]:
        ret["comment"].append("Step one will be applied to {}".format(device))
        return ret

cmd = [
        INSTALLATION_HELPER,
        "--step",
        "1",
        "--device",
        device,
        "--description",
        description,
    ]
    res = __salt__["cmd.run_all"](cmd)

if res["retcode"] or res["stderr"]:
        ret["comment"].append("Failed to execute step one {}".format(res["stderr"]))
    else:
        ret["result"] = True
        ret["changes"]["step one"] = True
    return ret

@__mount_device
def step_two(name, device, prefix=None, __dest=None):
    """
    Step two of the installation-helper tool

name
       Name of the state

device
        Device where to install snapper

prefix
        Default root prefix for the subvolumes

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

snapshots = os.path.join(__dest, ".snapshots")
    if os.path.exists(snapshots):
        ret["result"] = None if __opts__["test"] else True
        ret["comment"].append("Step two aleady applied to {}".format(device))
        return ret

if __opts__["test"]:
        ret["comment"].append("Step two will be applied to {}".format(device))
        return ret

cmd = [
        INSTALLATION_HELPER,
        "--step",
        "2",
        "--device",
        device,
        "--root-prefix",
        __dest,
    ]

if prefix:
        cmd.extend(["--default-subvolume-name", prefix])

res = __salt__["cmd.run_all"](cmd)

if res["retcode"] or res["stderr"]:
        ret["comment"].append("Failed to execute step two {}".format(res["stderr"]))
    else:
        ret["result"] = True
        ret["changes"]["step two"] = True

# Internally step two mounts a new subvolume called .snapshots
    for i in range(5):
        res = __salt__["mount.umount"](snapshots)
        if res is not True:
            log.warning("Retry %s: Failed to umount %s: %s", i, snapshots, res)
        else:
            break
    else:
        # We fail to umount .snapshots directory, bit the installation
        # step was properly executed, so we still return True
        ret["comment"].append("Failed to umount {}: {}".format(snapshots, res))

return ret

def step_four(name, root):
    """
    Step four of the installation-helper tool

name
        Name of the state

root
        Target directory where to chroot

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if os.path.exists(os.path.join(root, ".snapshots/grub-snapshot.cfg")):
        ret["result"] = None if __opts__["test"] else True
        ret["comment"].append("Step four already applied to {}".format(root))
        return ret

if __opts__["test"]:
        ret["comment"].append("Step four will be applied to {}".format(root))
        return ret

cmd = [INSTALLATION_HELPER, "--step", "4"]
    res = __salt__["cmd.run_chroot"](root, cmd)

if res["retcode"] or res["stderr"]:
        ret["comment"].append("Failed to execute step four {}".format(res["stderr"]))
        return ret

# Set the initial configuration and quota as YaST is doing
    cmd = [
        SNAPPER,
        "--no-dbus",
        "set-config",
        "NUMBER_CLEANUP=yes",
        "NUMBER_LIMIT=2-10",
        "NUMBER_LIMIT_IMPORTANT=4-10",
        "TIMELINE_CREATE=no",
    ]
    res = __salt__["cmd.run_chroot"](root, cmd)

if res["retcode"] or res["stderr"]:
        ret["comment"].append(
            "Failed to set configuration in step four {}".format(res["stderr"])
        )
        return ret

cmd = [SNAPPER, "--no-dbus", "setup-quota"]
    res = __salt__["cmd.run_chroot"](root, cmd)

if res["retcode"] or res["stderr"]:
        ret["comment"].append(
            "Failed to set quota in step four {}".format(res["stderr"])
        )
        return ret

ret["result"] = True
    ret["changes"]["step four"] = True
    return ret

def step_five(name, root, snapshot_type, description, important, cleanup):
    """
    Step five of the installation-helper tool

name
        Name of the state

root
        Target directory where to chroot

snapshot_type
        Type of snapshot: {single, pre, post}

description
        Description for the snapshot

important
        Is the snapshot important

cleanup
        Type or snapper cleanup angorithm: {number, timeline,
        empty-pre-post}

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if snapshot_type not in ("single", "pre", "post"):
        ret["comment"].append("Value for snapshot_type not recognized")
        return ret

if not description:
        ret["comment"].append("Value for description is empty")
        return ret

if cleanup not in ("number", "timeline", " empty-pre-post "):
        ret["comment"].append("Value for cleanup not recognized")
        return ret

cmd = [SNAPPER, "--no-dbus", "list"]
    res = __salt__["cmd.run_chroot"](root, cmd)

if res["retcode"] or res["stderr"]:
        ret["comment"].append(
            "Failed to list snapshots in step five {}".format(res["stderr"])
        )
        return ret

if description in res["stdout"]:
        ret["result"] = None if __opts__["test"] else True
        ret["comment"].append("Step five already applied to {}".format(root))
        return ret

if __opts__["test"]:
        ret["comment"].append("Step five will be applied to {}".format(root))
        return ret

cmd = [
        INSTALLATION_HELPER,
        "--step",
        "5",
        "--snapshot-type",
        snapshot_type,
        "--description",
        '"{}"'.format(description),
        "--userdata",
        "important={}".format("yes" if important else "no"),
        "--cleanup",
        cleanup,
    ]
    res = __salt__["cmd.run_chroot"](root, cmd)

if res["retcode"] or res["stderr"]:
        ret["comment"].append("Failed to execute step five {}".format(res["stderr"]))
    else:
        ret["result"] = True
        ret["changes"]["step five"] = True
    return ret
0707010000002F000081A40000427000000032000000015F4E04F800001A91000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_states/suseconnect.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

from salt.exceptions import CommandExecutionError

LOG = logging.getLogger(__name__)

__virtualname__ = "suseconnect"

def __virtual__():
    """
    SUSEConnect module is required
    """
    return "suseconnect.register" in __salt__

def _status(root):
    """
    Return the list of resitered modules and subscriptions
    """
    status = __salt__["suseconnect.status"](root=root)
    registered = [
        "{}/{}/{}".format(i["identifier"], i["version"], i["arch"])
        for i in status
        if i["status"] == "Registered"
    ]
    subscriptions = [
        "{}/{}/{}".format(i["identifier"], i["version"], i["arch"])
        for i in status
        if i.get("subscription_status") == "ACTIVE"
    ]
    return registered, subscriptions

def _is_registered(product, root):
    """
    Check if a product is registered
    """
    # If the user provides a product, and the product is registered,
    # or if the user do not provide a product name, but some
    # subscription is active, we consider that there is nothing else
    # to do.
    registered, subscriptions = _status(root)
    if (product and product in registered) or (not product and subscriptions):
        return True
    return False

def registered(name, regcode, product=None, email=None, url=None, root=None):
    """
    .. versionadded:: TBD

name
       If follows the product name rule, will be the name of the
       product.

regcode
       Subscription registration code for the product to be
       registered. Relates that product to the specified subscription,
       and enalbes software repositories for that product.

email
       Email address for product registration

url
       URL for the registration server (will be saved for the next
       use) (e.g. https://scc.suse.com)

root
       Path to the root folder, uses the same parameter for zypper

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if not product and re.match(r"[-\w]+/[-\w\.]+/[-\w]+", name):
        product = name
    name = product if product else "default"

if _is_registered(product, root):
        ret["result"] = True
        ret["comment"].append("Product or module {} already registered".format(name))
        return ret

if __opts__["test"]:
        ret["result"] = None
        ret["comment"].append(
            "Product or module {} would be registered".format(name)
        )
        ret["changes"][name] = True
        return ret

try:
        __salt__["suseconnect.register"](
            regcode, product=product, email=email, url=url, root=root
        )
    except CommandExecutionError as e:
        ret["comment"].append("Error registering {}: {}".format(name, e))
        return ret

ret["changes"][name] = True

if _is_registered(product, root):
        ret["result"] = True
        ret["comment"].append("Product or module {} registered".format(name))
    else:
        ret["comment"].append("Product or module {} failed to register".format(name))

return ret

def deregistered(name, product=None, url=None, root=None):
    """
    .. versionadded:: TBD

name
       If follows the product name rule, will be the name of the
       product.

url
       URL for the registration server (will be saved for the next
       use) (e.g. https://scc.suse.com)

root
       Path to the root folder, uses the same parameter for zypper

"""
    ret = {
        "name": name,
        "result": False,
        "changes": {},
        "comment": [],
    }

if not product and re.match(r"[-\w]+/[-\w\.]+/[-\w]+", name):
        product = name
    name = product if product else "default"

if not _is_registered(product, root):
        ret["result"] = True
        ret["comment"].append(
            "Product or module {} already deregistered".format(name)
        )
        return ret

if __opts__["test"]:
        ret["result"] = None
        ret["comment"].append(
            "Product or module {} would be deregistered".format(name)
        )
        ret["changes"][name] = True
        return ret

try:
        __salt__["suseconnect.deregister"](product=product, url=url, root=root)
    except CommandExecutionError as e:
        ret["comment"].append("Error deregistering {}: {}".format(name, e))
        return ret

ret["changes"][name] = True

if not _is_registered(product, root):
        ret["result"] = True
        ret["comment"].append("Product or module {} deregistered".format(name))
    else:
        ret["comment"].append(
            "Product or module {} failed to deregister".format(name)
        )

return ret
07070100000030000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000002E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_utils07070100000031000081A40000427000000032000000015F4E04F800000689000000000000000000000000000000000000003600000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_utils/disk.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import re

class ParseException(Exception):
    pass

def units(value, default="MB"):
    """
    Split a value expressed (optionally) with units.

Returns the tuple (value, unit)
    """
    valid_units = (
        "s",
        "B",
        "kB",
        "MB",
        "MiB",
        "GB",
        "GiB",
        "TB",
        "TiB",
        "%",
        "cyl",
        "chs",
        "compact",
    )
    match = re.search(r"^([\d.]+)(\D*)$", str(value))
    if match:
        value, unit = match.groups()
        unit = unit if unit else default
        if unit in valid_units:
            return (float(value), unit)
        else:
            raise ParseException("{} not recognized as a valid unit".format(unit))
    raise ParseException("{} cannot be parsed".format(value))
07070100000032000081A40000427000000032000000015F4E04F800004145000000000000000000000000000000000000003400000000yomi-0.0.1+git.1598948600.9a9eab0/salt/_utils/lp.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

EQ = "="
LTE = "<="
GTE = ">="

MINIMIZE = "-"
MAXIMIZE = "+"

def _vec_scalar(vector, scalar):
    """Multiply a vector by an scalar."""
    return [v * scalar for v in vector]

def _vec_vec_scalar(vector_a, vector_b, scalar):
    """Linear combination of two vectors and a scalar."""
    return [a * scalar + b for a, b in zip(vector_a, vector_b)]

def _vec_plus_vec(vector_a, vector_b):
    """Sum of two vectors."""
    return [a + b for a, b in zip(vector_a, vector_b)]

class Model:
    """Class that represent a linear programming problem."""

def __init__(self, variables):
        """Create a model with named variables."""
        # All variables are bound and >= 0. We do not support
        # unbounded variables.
        self.variables = variables

self._constraints = []
        self._cost_function = None

self._slack_variables = []
        self._standard_constraints = []
        self._standard_cost_function = None

self._canonical_constraints = []
        self._canonical_cost_function = None
        self._canonical_artificial_function = None

def add_constraint(self, coefficients, operator, free_term):
        """Add a constraint in non-standard form."""
        # We can express constraints in a general form as:
        #
        #   a_1 x_1 + a_2 x_2 + ... + a_n x_n <= b
        #
        # For this case the values are:
        #   * coefficients = [a_1, a_2, ..., a_n]
        #   * operator = '<='
        #   * free_term = b
        #
        assert len(coefficients) == len(self.variables), (
            "Coefficients length must match the number of variables"
        )
        assert operator in (EQ, LTE, GTE), "Operator not valid"
        self._constraints.append((coefficients, operator, free_term))

def add_cost_function(self, action, coefficients, free_term):
        """Add a cost function in non-standard form."""
        # We can express a cost function as:
        #
        #   Miminize: z = c_1 x_1 + c_2 x_2 + ... + c_n x_n + z_0
        #
        # For this case the values are:
        #   * action = '-'
        #   * coefficients = [c_1, c_2, ..., c_n]
        #   * free_term = z_0
        #
        assert action in (MINIMIZE, MAXIMIZE), "Action not valid"
        assert len(coefficients) == len(self.variables), (
            "Coefficients length must match the number of variables"
        )
        self._cost_function = (action, coefficients, free_term)

def _coeff(self, coefficients):
        """Translate a coefficients dictionary into a list."""
        coeff = [0] * len(self.variables)
        for idx, variable in enumerate(self.variables):
            coeff[idx] = coefficients.get(variable, 0)
        return coeff

def add_constraint_named(self, coefficients, operator, free_term):
        """Add a constraint in non-standard form."""
        self.add_constraint(self._coeff(coefficients), operator, free_term)

def add_cost_function_named(self, action, coefficients, free_term):
        """Add a cost function in non-standard form."""
        self.add_cost_function(action, self._coeff(coefficients), free_term)

def simplex(self):
        """Resolve a linear programing model."""
        self._convert_to_standard_form()
        self._convert_to_canonical_form()
        tableau = self._build_tableau_canonical_form()
        tableau.simplex()
        tableau.drop_artificial()
        tableau.simplex()

constraints = tableau.constraints()
        solution = {i: 0 for i in self.variables}
        for idx_cons, idx_var in enumerate(tableau._basic_variables):
            try:
                variable = self.variables[idx_var]
                solution[variable] = constraints[idx_cons][-1]
            except IndexError:
                pass
        return solution

def _convert_to_standard_form(self):
        """Convert constraints and cost function to standard form."""
        slack_vars = len([c for c in self._constraints if c[1] != EQ])

self._standard_constraints = []
        slack_var_idx = 0
        base_slack_var_idx = len(self.variables)
        for coefficients, operator, free_term in self._constraints:
            slack_coeff = [0] * slack_vars
            if operator in (LTE, GTE):
                slack_coeff[slack_var_idx] = 1 if operator == LTE else -1
                self._slack_variables.append(base_slack_var_idx + slack_var_idx)
                slack_var_idx += 1
            self._standard_constraints.append((coefficients + slack_coeff, free_term))

# Adjust the cost function
        action, coefficients, free_term = self._cost_function
        slack_coeff = [0] * slack_vars
        if action == MAXIMIZE:
            coefficients = _vec_scalar(coefficients, -1)
        self._standard_cost_function = (coefficients + slack_coeff, -free_term)

def _convert_to_canonical_form(self):
        """Convert the model into canonical form."""
        artificial_vars = len(self._constraints)

self._canonical_constraints = []
        artificial_var_idx = 0

slack_vars = len([c for c in self._constraints if c[1] != EQ])
        coeff_acc = [0] * (len(self.variables) + slack_vars)

free_term_acc = 0
        for coefficients, free_term in self._standard_constraints:
            if free_term < 0:
                coefficients = _vec_scalar(coefficients, -1)
                free_term *= -1
            artificial_coeff = [0] * artificial_vars
            artificial_coeff[artificial_var_idx] = 1
            artificial_var_idx += 1
            self._canonical_constraints.append(
                (coefficients + artificial_coeff, free_term)
            )

coeff_acc = _vec_plus_vec(coeff_acc, coefficients)
            free_term_acc += free_term

coefficients, free_term = self._standard_cost_function
        artificial_coeff = [0] * artificial_vars
        self._canonical_cost_function = (coefficients + artificial_coeff, free_term)

coeff_acc = _vec_scalar(coeff_acc, -1)
        self._canonical_artificial_function = (
            coeff_acc + artificial_coeff,
            -free_term_acc,
        )

def _build_tableau_canonical_form(self):
        """Build the tableau related with the canonical form."""
        # Total number of variables
        n = len(self._canonical_artificial_function[0])
        # Basic variables (in canonical form there is one per constraint)
        m = len(self._constraints)
        tableau = Tableau(n, m)
        canonical_constraints = enumerate(self._canonical_constraints)
        for (idx, (coefficients, free_term)) in canonical_constraints:
            tableau.add_constraint(coefficients + [free_term], n - m + idx)

coefficients, free_term = self._canonical_cost_function
        tableau.add_cost_function(coefficients + [free_term])

coefficients, free_term = self._canonical_artificial_function
        tableau.add_artificial_function(coefficients + [free_term])
        return tableau

def _str_coeff(self, coefficients):
        """Transform a coefficient array into a string."""
        result = []
        for coefficient, variable in zip(coefficients, self.variables):
            if result:
                result.append("+" if coefficient >= 0 else "-")
                coefficient = abs(coefficient)
            result.append("{} {}".format(coefficient, variable))
        return " ".join(result)

def __str__(self):
        result = []
        """String representation of a model."""
        if self._cost_function:
            result.append(
                {MINIMIZE: "Minimize:", MAXIMIZE: "Maximize:"}[self._cost_function[0]]
            )
            free_term = self._cost_function[2]
            free_term_sign = "+" if free_term >= 0 else "-"
            z = " ".join(
                (
                    self._str_coeff(self._cost_function[1]),
                    free_term_sign,
                    str(abs(free_term)),
                )
            )
            result.append("  " + z)
            result.append("")

result.append("Subject to:")
        for constraint in self._constraints:
            c = " ".join(
                (self._str_coeff(constraint[0]), constraint[1], str(constraint[2]))
            )
            result.append("  " + c)

c = ", ".join(self.variables) + " >= 0"
        result.append("  " + c)

return "\n".join(result)

class Tableau:
    # To sumarize the steps of the simplex method, starting with the
    # problem in canonical form.
    #
    # 1. if all c_j >= 0, the minimum value of the objective function
    #    has been achieved.
    #
    # 2. If there exists an s such that c_s < 0 and a_{is} <= 0 for
    #    all i, the objective function is not bounded below.
    #
    # 3. Otherwise, pivot. To determine the pivot term:
    #
    #    (a) Pivot in any column with a negative c_j term. If there
    #    are several negative c_j's, pivoting in the column with the
    #    smallest c_j may reduce the total number of steps necessary
    #    to complete the problem. Assume that we pivot column s.
    #
    #    (b) To determine the row of the pivot of the pivot term, find
    #    that row, say row r, such that
    #
    #      b_r / a_{rs} = Min { b_i / a_{is}: a_{is} > 0 }
    #
    #    Notice that here only those ratios b_i / a_{is} with a_{is} >
    #    0 are considered. If the minimum of there ratios is attained
    #    in several rows, a simple rule such as choosing the row with
    #    the smallest index can be used to determine the pivoting row.
    #
    # 4. After pivoting, the problem remains in canonical form at a
    #    different basic feasible solution. Now return to step 1.
    #
    # If the problem contains a degenerate b.f.s., proceed as above.

def __init__(self, n, m):
        self.n = n
        self.m = m

self._basic_variables = []
        self._tableau = []

self._artificial = False

def add_constraint(self, constraint, basic_variable):
        """Add a contraint into the tableau."""
        assert len(constraint) == self.n + 1, "Wrong size for the constraint"
        assert (
            basic_variable not in self._basic_variables
        ), "Basic variable is already registered"
        assert (
            len(self._basic_variables) == len(self._tableau)
            and len(self._tableau) < self.m
        ), "Too many constraints registered"

self._basic_variables.append(basic_variable)
        self._tableau.append(constraint)

def add_cost_function(self, cost_function):
        """Add the const function in the tableau."""
        assert len(cost_function) == self.n + 1, "Wrong size for the cost function"
        assert (
            len(self._basic_variables) == len(self._tableau)
            and len(self._tableau) == self.m
        ), "Too few constraints registered"

self._tableau.append(cost_function)

def add_artificial_function(self, artificial_function):
        """Add the artificial function in the tableau."""
        assert (
            len(artificial_function) == self.n + 1
        ), "Wrong size for the cost function"
        assert (
            len(self._basic_variables) == len(self._tableau) - 1
            and len(self._tableau) == self.m + 1
        ), ("Too few constraints or not cost function registered")

self._artificial = True
        self._tableau.append(artificial_function)

def constraints(self):
        """Return the constraints in the tableau."""
        last = -1 if not self._artificial else -2
        return self._tableau[:last]

def cost_function(self):
        """Return the cost function in the tableau."""
        # If we use the artificial cost function, is still in the last
        # position.
        return self._tableau[-1]

def drop_artificial(self):
        """Transform the tableau in one without artificial variables."""
        assert self._artificial, "Tableau already without artificial variables"
        assert self.is_minimum(), "Tableau is not in minimum state"

# Check that the basic variables are not artificial variables
        artificial_variables = range(self.n - self.m, self.n)
        assert not any(
            i in self._basic_variables for i in artificial_variables
        ), "At least one artificial variable is a basic variable"

# Remove the artificial cost function
        self._tableau.pop()

# Drop all artificial variable coefficients
        tableau = []
        for line in self._tableau:
            tableau.append(line[: -self.m - 1] + [line[-1]])
        self._tableau = tableau

self._artificial = False

def simplex(self):
        """Resolve the constraints via the simplex algorithm."""
        while not self.is_minimum():
            column = self._get_pivoting_column()
            row = self._get_pivoting_row(column)
            self._pivote(row, column)
            self._basic_variables[row] = column

def is_canonical(self):
        """Check if is in canonical form."""
        result = True

# The system of constraints is in canonical form
        for idx, constraint in zip(self._basic_variables, self.constraints()):
            result = result and all(
                constraint[i] == (1 if idx == i else 0) for i in self._basic_variables
            )

# We need to check that the associated basic solution is
        # feasible. But we separate this check in a different method.
        # result = result and self.is_basic_feasible_solution()

# The objective function is expressed in therms of only the
        # nonbasic variables
        cost_function = self.cost_function()
        result = result and all(cost_function[i] == 0 for i in self._basic_variables)
        return result

def is_minimum(self):
        """Check if the cost function is already minimized."""
        return all(c >= 0 for c in self.cost_function()[:-1])

def is_basic_feasible_solution(self):
        """Check if there is a basic feasible solution."""
        assert self.is_canonical(), "Tableau is not in canonical form"

if self._artificial:
            assert self.is_minimum(), (
                "If there are artificial variables, we need to be minimized."
            )
            return self.cost_functions()[-1] == 0
        else:
            return all(c[-1] >= 0 for c in self.constraints())

def is_bound(self):
        """Check if the cost function is bounded."""
        candidates_idx = [i for i, c in enumerate(self.cost_function()[:-1]) if c < 0]
        return all(
            all(row[i] >= 0 for row in self.constraints()) for i in candidates_idx
        )

def _get_pivoting_column(self):
        """Returm the column number where we can pivot."""
        candidates = [(i, c) for i, c in enumerate(self.cost_function()[:-1]) if c < 0]
        assert candidates, "Cost function already minimal."
        return min(candidates, key=lambda x: x[1])[0]

def _get_pivoting_row(self, column):
        """Return the row number where we can pivot."""
        candidates = [
            (i, row[-1] / row[column])
            for i, row in enumerate(self.constraints())
            if row[column] > 0
        ]
        # NOTE(aplanas): Not sure that this is the case
        assert candidates, "Not basic feasible solution found."
        return min(candidates, key=lambda x: x[1])[0]

def _pivote(self, row, column):
        """Pivote the tableau in (row, column)."""
        # Normalize the row
        vec = _vec_scalar(self._tableau[row], 1 / self._tableau[row][column])
        self._tableau[row] = vec
        for row_b, vec_b in enumerate(self._tableau):
            if row_b != row:
                self._tableau[row_b] = _vec_vec_scalar(vec, vec_b, -vec_b[column])
07070100000033000081A40000427000000032000000015F4E04F8000006CF000000000000000000000000000000000000003200000000yomi-0.0.1+git.1598948600.9a9eab0/salt/macros.yml# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
{% set config = pillar['config'] %}

{% macro send_enter(name) -%}
event_{{ name }}_enter:
  module.run:
    - event.send:
      - tag: yomi/{{ name }}/enter
      # - with_grains: [id, hwaddr_interfaces]
{%- endmacro %}

{% macro send_success(state, name) -%}
event_{{ name }}_success:
  module.run:
    - event.send:
      - tag: yomi/{{ name }}/success
      # - with_grains: [id, hwaddr_interfaces]
    - onchanges:
      - {{ state }}: {{ name }}
{%- endmacro %}

{% macro send_fail(state, name) -%}
event_{{ name }}_fail:
  module.run:
    - event.send:
      - tag: yomi/{{ name }}/fail
      # - with_grains: [id, hwaddr_interfaces]
    - onfail:
      - {{ state }}: {{ name }}
{%- endmacro %}

{% macro log(state, name) -%}
{% if config.get('events', True) %}
{{ send_enter(name) }}
{{ send_success(state, name) }}
{{ send_fail(state, name) }}
{% endif %}
{%- endmacro %}

07070100000034000081A40000427000000032000000015F4E04F800000018000000000000000000000000000000000000002F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/top.slsbase:
  '*':
    - yomi
07070100000035000041ED0000427000000032000000075F4E04F800000000000000000000000000000000000000000000002C00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi07070100000036000081A40000427000000032000000015F4E04F80000016C000000000000000000000000000000000000004000000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/_default_target.sls{% import 'macros.yml' as macros %}

{% set config = pillar['config'] %}
{% set target = config.get('target', 'multi-user.target') %}

{{ macros.log('cmd', 'systemd_set_target') }}
systemd_set_target:
  cmd.run:
    - name: systemctl set-default {{ target }}
    - unless: readlink -f /mnt/etc/systemd/system/default.target | grep -q {{ target }}
    - root: /mnt
07070100000037000081A40000427000000032000000015F4E04F8000004A0000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/_firstboot.sls{% import 'macros.yml' as macros %}

{% set config = pillar['config'] %}

# We execute the systemctl call inside the chroot, so we can guarantee
# that will work on containers
{{ macros.log('module', 'systemd_firstboot') }}
systemd_firstboot:
  module.run:
    - chroot.call:
      - root: /mnt
      - function: service.firstboot
      - locale: {{ config.get('locale', 'en_US.utf8') }}
{% if config.get('locale_messages') %}
      - locale_message: {{ config['locale_messages'] }}
{% endif %}
      - keymap: {{ config.get('keymap', 'us') }}
      - timezone: {{ config.get('timezone', 'UTC') }}
{% if config.get('hostname') %}
      - hostname: {{ config['hostname'] }}
{% endif %}
{% if config.get('machine_id') %}
      - machine_id: {{ config['machine_id'] }}
{% endif %}
    - creates:
        - /mnt/etc/hostname
        - /mnt/etc/locale.conf
        - /mnt/etc/localtime
        - /mnt/etc/machine-id
        - /mnt/etc/vconsole.conf

{% if not config.get('machine_id') %}
{{ macros.log('module', 'create_machine-id') }}
create_machine-id:
  module.run:
    - file.copy:
      - src: /etc/machine-id
      - dst: /mnt/etc/machine-id
      - remove_existing: yes
{% endif %}
07070100000038000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003700000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/bootloader07070100000039000081A40000427000000032000000015F4E04F800000327000000000000000000000000000000000000004900000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/bootloader/grub2_install.sls{% import 'macros.yml' as macros %}

{% set bootloader = pillar['bootloader'] %}
{% set arch = {'aarch64': 'arm64'}.get(grains['cpuarch'], grains['cpuarch'])%}

{{ macros.log('cmd', 'grub2_install') }}
grub2_install:
  cmd.run:
{% if grains['efi'] %}
  {% if grains['efi-secure-boot'] %}
    - name: shim-install --config-file=/boot/grub2/grub.cfg
  {% else %}
    - name: grub2-install --target={{ arch }}-efi --efi-directory=/boot/efi --bootloader-id=GRUB
  {% endif %}
    - creates: /mnt/boot/efi/EFI/GRUB
{% else %}
    - name: grub2-install --force {{ bootloader.device }}
    - creates: /mnt/boot/grub2/i386-pc/normal.mod
{% endif %}
{% if pillar.get('lvm') %}
    - binds: [/run]
    - env:
      - LVM_SUPPRESS_FD_WARNINGS: 1
{% endif %}
    - root: /mnt
    - require:
      - cmd: grub2_mkconfig
0707010000003A000081A40000427000000032000000015F4E04F80000086B000000000000000000000000000000000000004A00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/bootloader/grub2_mkconfig.sls{% import 'macros.yml' as macros %}

{% set config = pillar['config'] %}
{% set bootloader = pillar['bootloader'] %}

{% if config.get('snapper') %}
include:
  {% if config.get('snapper') %}
  - ..storage.snapper.grub2_mkconfig
  {% endif %}
{% endif %}

{% if grains['efi'] and grains['cpuarch'] != 'aarch64' %}
{{ macros.log('file', 'config_grub2_efi') }}
config_grub2_efi:
  file.append:
    - name: /mnt/etc/default/grub
    - text: GRUB_USE_LINUXEFI="true"
{% endif %}

{% if bootloader.get('theme') %}
{{ macros.log('file', 'config_grub2_theme') }}
config_grub2_theme:
  file.append:
    - name: /mnt/etc/default/grub
    - text:
      - GRUB_TERMINAL="{{ bootloader.get('terminal', 'gfxterm') }}"
      - GRUB_GFXMODE="{{ bootloader.get('gfxmode', 'auto') }}"
      - GRUB_BACKGROUND=
      # - GRUB_THEME="/boot/grub2/themes/openSUSE/theme.txt"
{% endif %}

{{ macros.log('file', 'config_grub2_resume') }}
config_grub2_resume:
  file.append:
    - name: /mnt/etc/default/grub
    - text:
      - GRUB_TIMEOUT={{ bootloader.get('timeout', 8) }}
{% if not pillar.get('lvm') %}
      - GRUB_DEFAULT="saved"
      # - GRUB_SAVEDEFAULT="true"
{% endif %}

{% set serial_command = bootloader.get('serial_command')%}
{{ macros.log('file', 'config_grub2_config') }}
config_grub2_config:
  file.append:
    - name: /mnt/etc/default/grub
    - text:
      - GRUB_CMDLINE_LINUX_DEFAULT="{{ bootloader.get('kernel', 'splash=silent quiet') }}"
      - GRUB_DISABLE_OS_PROBER="{{ true if bootloader.get('disable_os_prober') else false }}"
{% if serial_command %}
      - GRUB_TERMINAL="serial"
      - GRUB_SERIAL_COMMAND="{{ serial_command }}"
{% endif %}

{{ macros.log('cmd', 'grub2_set_default') }}
grub2_set_default:
  cmd.run:
    - name: (source /etc/os-release; grub2-set-default "${PRETTY_NAME}")
    - root: /mnt
    - onlyif: "[ -e /mnt/etc/os-release ]"
    - watch:
      - file: /mnt/etc/default/grub

{{ macros.log('cmd', 'grub2_mkconfig') }}
grub2_mkconfig:
  cmd.run:
    - name: grub2-mkconfig -o /boot/grub2/grub.cfg
    - root: /mnt
{% if pillar.get('lvm') %}
    - binds: [/run]
{% endif %}
    - watch:
      - file: /mnt/etc/default/grub
0707010000003B000081A40000427000000032000000015F4E04F800000055000000000000000000000000000000000000004000000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/bootloader/init.sls{% set config = pillar['config'] %}

include:
  - .grub2_mkconfig
  - .grub2_install
0707010000003C000081A40000427000000032000000015F4E04F80000023B000000000000000000000000000000000000004400000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/bootloader/software.sls{% import 'macros.yml' as macros %}

{% set bootloader = pillar['bootloader'] %}
{% set arch = {'aarch64': 'arm64'}.get(grains['cpuarch'], grains['cpuarch'])%}

{{ macros.log('pkg', 'install_grub2') }}
install_grub2:
  pkg.installed:
    - pkgs:
      - grub2
{% if bootloader.get('theme') %}
      - grub2-branding
{% endif %}
{% if grains['efi'] %}
      - grub2-{{ arch }}-efi
  {% if grains['efi-secure-boot'] %}
      - shim
  {% endif %}
{% endif %}
    - resolve_capabilities: yes
    - no_recommends: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
0707010000003D000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003300000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/chroot0707010000003E000081A40000427000000032000000015F4E04F80000015F000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/chroot/mount.sls{% import 'macros.yml' as macros %}

{% for fstype, fs_file in (('devtmpfs', '/mnt/dev'), ('proc', '/mnt/proc'), ('sysfs', '/mnt/sys')) %}
{{ macros.log('mount', 'mount_' ~ fs_file) }}
mount_{{ fs_file }}:
  mount.mounted:
    - name: {{ fs_file }}
    - device: {{ fstype }}
    - fstype: {{ fstype }}
    - mkmnt: yes
    - persist: no
{% endfor %}
0707010000003F000081A40000427000000032000000015F4E04F800000131000000000000000000000000000000000000004400000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/chroot/post_install.sls{% import 'macros.yml' as macros %}

{{ macros.log('module', 'unfreeze_chroot') }}
unfreeze_chroot:
  module.run:
    - freezer.restore:
      - name: yomi-chroot
      - clean: True
      - includes: [pattern]
      - root: /mnt
    - onlyif: "[ -e /var/cache/salt/minion/freezer/yomi-chroot-pkgs.yml ]"
07070100000040000081A40000427000000032000000015F4E04F8000001FC000000000000000000000000000000000000004000000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/chroot/software.sls{% import 'macros.yml' as macros %}

{{ macros.log('module', 'freeze_chroot') }}
freeze_chroot:
  module.run:
    - freezer.freeze:
      - name: yomi-chroot
      - includes: [pattern]
      - root: /mnt
    - unless: "[ -e /var/cache/salt/minion/freezer/yomi-chroot-pkgs.yml ]"

{{ macros.log('pkg', 'install_python3-base') }}
install_python3-base:
  pkg.installed:
    - name: python3-base
    - no_recommends: yes
    - resolve_capabilities: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
07070100000041000081A40000427000000032000000015F4E04F800000104000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/chroot/umount.sls{% import 'macros.yml' as macros %}

{% for fs_file in ('/mnt/sys', '/mnt/proc', '/mnt/dev' ) %}
{{ macros.log('mount', 'umount_' ~ fs_file) }}
umount_{{ fs_file }}:
  mount.unmounted:
    - name: {{ fs_file }}
    - requires: mount_{{ fs_file }}
{% endfor %}
07070100000042000081A40000427000000032000000015F4E04F8000001E6000000000000000000000000000000000000003500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/init.sls{% set filesystems = pillar['filesystems'] %}

{% set ns = namespace(installed=False) %}
{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
    {% if salt.cmd.run('findmnt --list --noheadings --output SOURCE /') == device %}
      {% set ns.installed = True %}
    {% endif %}
  {% endif %}
{% endfor %}

{% if not ns.installed %}
include:
  - .storage
  - .software
  - .users
  - .bootloader
  - .services
  - .post_install
  - .reboot
{% endif %}
07070100000043000081A40000427000000032000000015F4E04F800000061000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/post_install.slsinclude:
  - .chroot.post_install
  - ._firstboot
  - ._default_target
  - .storage.post_install
07070100000044000081A40000427000000032000000015F4E04F800000439000000000000000000000000000000000000003700000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/reboot.sls{% import 'macros.yml' as macros %}

{% set config = pillar['config'] %}
{% set reboot = config.get('reboot', True) %}

{% if reboot == 'kexec' %}
{{ macros.log('cmd', 'grub_command_line') }}
grub_command_line:
  cmd.run:
    - name: grep -m 1 -E '^[[:space:]]*linux(efi)?[[:space:]]+[^[:space:]]+vmlinuz.*$' /mnt/boot/grub2/grub.cfg | cut -d ' ' -f 2-3 > /tmp/command_line
    - create: /tmp/command_line

{{ macros.log('cmd', 'prepare_kexec') }}
prepare_kexec:
  cmd.run:
    - name: kexec -a -l /mnt/boot/vmlinuz --initrd=/mnt/boot/initrd --command-line="$(cat /tmp/command_line)"
    - onlyif: "[ -e /tmp/command_line ]"

{{ macros.log('cmd', 'execute_kexec') }}
execute_kexec:
  cmd.run:
    - name: systemctl kexec

{% elif reboot == 'halt' %}
{{ macros.log('module', 'halt') }}
halt:
  module.run:
    - system.halt:

{% elif reboot == 'shutdown' %}
{{ macros.log('module', 'shutdown') }}
shutdown:
  module.run:
    - system.shutdown:

{% elif reboot == 'yes' or reboot == True %}
{{ macros.log('module', 'reboot') }}
reboot:
  module.run:
    - system.reboot:
{% endif %}
07070100000045000041ED0000427000000032000000035F4E04F800000000000000000000000000000000000000000000003500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/services07070100000046000081A40000427000000032000000015F4E04F8000003C6000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/services/init.sls{% import 'macros.yml' as macros %}

{% set services = pillar.get('services', {}) %}

include:
  - .network
{% if pillar.get('salt-minion') %}
  - .salt-minion
{% endif %}

{% for service in services.get('enabled', []) %}
# We execute the systemctl call inside the chroot, so we can guarantee
# that will work on containers
{{ macros.log('module', 'enable_service_' ~ service) }}
enable_service_{{ service }}:
  module.run:
    - chroot.call:
      - root: /mnt
      - function: service.enable
      - name: {{ service }}
    - unless: systemctl --root=/mnt --quiet is-enabled {{ service }} 2> /dev/null
{% endfor %}

{% for service in services.get('disabled', []) %}
{{ macros.log('module', 'disable_service_' ~ service) }}
disable_service_{{ service }}:
  module.run:
    - chroot.call:
      - root: /mnt
      - function: service.disable
      - name: {{ service }}
    - onlyif: systemctl --root=/mnt --quiet is-enabled {{ service }} 2> /dev/null
{% endfor %}
07070100000047000081A40000427000000032000000015F4E04F8000007DF000000000000000000000000000000000000004100000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/services/network.sls{% import 'macros.yml' as macros %}

{% set networks = pillar.get('networks') %}

{% if networks %}
  {% for network in networks %}
create_ifcfg_{{ network.interface }}:
  file.append:
    - name: /mnt/etc/sysconfig/network/ifcfg-{{ network.interface }}
    - text: |
        BOOTPROTO='dhcp'
        BROADCAST=''
        ETHTOOL_OPTIONS=''
        IPADDR=''
        MTU=''
        NAME=''
        NETMASK=''
        NETWORK=''
        REMOTE_IPADDR=''
        STARTMODE='auto'
  {% endfor %}
{% else %}
# This assume that the image used for deployment is under a
# predictable network interface name, like Tumbleweed. For SLE, boot
# the image with `net.ifnames=1`

{% set interfaces = salt.network.interfaces() %}
  {% set interfaces_except_lo = interfaces | select('!=', 'lo') %}

{% for interface in interfaces_except_lo %}
{{ macros.log('file', 'create_ifcfg_' ~ interface) }}
create_ifcfg_{{ interface }}:
  file.append:
    - name: /mnt/etc/sysconfig/network/ifcfg-{{ interface }}
    - text: |
        BOOTPROTO='dhcp'
        BROADCAST=''
        ETHTOOL_OPTIONS=''
        IPADDR=''
        MTU=''
        NAME=''
        NETMASK=''
        NETWORK=''
        REMOTE_IPADDR=''
        STARTMODE='auto'
    - unless: "[ -e /mnt/usr/lib/udev/rules.d/75-persistent-net-generator.rules ]"

{{ macros.log('file', 'create_ifcfg_eth' ~ loop.index0) }}
create_ifcfg_eth{{ loop.index0 }}:
  file.append:
    - name: /mnt/etc/sysconfig/network/ifcfg-eth{{ loop.index0 }}
    - text: |
        BOOTPROTO='dhcp'
        BROADCAST=''
        ETHTOOL_OPTIONS=''
        IPADDR=''
        MTU=''
        NAME=''
        NETMASK=''
        NETWORK=''
        REMOTE_IPADDR=''
        STARTMODE='auto'
    - onlyif: "[ -e /mnt/usr/lib/udev/rules.d/75-persistent-net-generator.rules ]"
  {% endfor %}
{% endif %}

{{ macros.log('file', 'dhcp_hostname') }}
dhcp_hostname:
  file.append:
    - name: /mnt/etc/sysconfig/network/dhcp
    - text:
        - DHCLIENT_SET_HOSTNAME="yes"
        - WRITE_HOSTNAME_TO_HOSTS="no"
07070100000048000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000004100000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/services/salt-minion07070100000049000081A40000427000000032000000015F4E04F80000036C000000000000000000000000000000000000004A00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/services/salt-minion/init.sls{% import 'macros.yml' as macros %}

{% set salt_minion = pillar['salt-minion'] %}

{% if salt_minion.get('config') %}
{{ macros.log('module', 'synchronize_salt-minion_etc') }}
synchronize_salt-minion_etc:
  module.run:
    - file.copy:
      - src: /etc/salt
      - dst: /mnt/etc/salt
      - recurse: yes
      - remove_existing: yes
    - unless: "[ -e /mnt/etc/salt/pki/minion/minion.pem ]"

{{ macros.log('module', 'synchronize_salt-minion_var') }}
synchronize_salt-minion_var:
  module.run:
    - file.copy:
      - src: /var/cache/salt
      - dst: /mnt/var/cache/salt
      - recurse: yes
      - remove_existing: yes
    - unless: "[ -e /mnt/var/cache/salt/minion/extmods ]"

{{ macros.log('module', 'clean_salt-minion_var') }}
clean_salt-minion_var:
  file.tidied:
    - name: /mnt/var/cache/salt/minion
    - matches:
      - ".*\\.pyc"
      - "\\d+"
{% endif %}
0707010000004A000081A40000427000000032000000015F4E04F8000000E5000000000000000000000000000000000000004E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/services/salt-minion/software.sls{% import 'macros.yml' as macros %}

{{ macros.log('pkg', 'install_salt-minion') }}
install_salt-minion:
  pkg.installed:
    - name: salt-minion
    - no_recommends: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
0707010000004B000081A40000427000000032000000015F4E04F800000085000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/services/software.sls{% if pillar.get('salt-minion') %}
include:
  {% if pillar.get('salt-minion') %}
  - .salt-minion.software
  {% endif %}
{% endif %}
0707010000004C000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/software0707010000004D000081A40000427000000032000000015F4E04F8000002A1000000000000000000000000000000000000003F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/software/image.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}
{% set software = pillar['software'] %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
{{ macros.log('module', 'dump_image_into_' ~ device) }}
dump_image_into_{{ device }}:
  images.dumped:
    - name: {{ software.image.url }}
    - device: {{ device }}
    {% for checksum_type in ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512') %}
      {% if checksum_type in software.image %}
    - checksum_type: {{ checksum_type }}
    - checksum: {{ software.image[checksum_type] or '' }}
      {% endif %}
    {% endfor %}
  {% endif %}
{% endfor %}
0707010000004E000081A40000427000000032000000015F4E04F8000001A4000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/software/init.sls{% set software = pillar['software'] %}

include:
{# TODO: Remove the double check (SumaForm bug) #}
{% if software.get('image', {}).get('url') %}
  - .image
  - ..storage.fstab
  - ..storage.mount
{% endif %}
  - .software
{% if pillar.get('suseconnect', {}).get('config', {}).get('regcode') %}
  - .suseconnect
{% endif %}
  - ..storage.software
  - ..bootloader.software
  - ..services.software
  - ..chroot.software
0707010000004F000081A40000427000000032000000015F4E04F800000501000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/software/software.sls{% import 'macros.yml' as macros %}

{% set software = pillar['software'] %}
{% set software_config = software.get('config', {}) %}

{% for name, repo in software.get('repositories', {}).items() %}
{{ macros.log('pkgrepo', 'add_repository_' ~ repo) }}
add_repository_{{ repo }}:
  pkgrepo.managed:
    - name: {{ name }}
    - baseurl: {{ repo }}
    - refresh: yes
    - gpgautoimport: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
{% endfor %}

{% if software_config.get('minimal') %}
{{ macros.log('file', 'config_zypp_minimal_host') }}
config_zypp_minimal_host:
  file.append:
    - name: /etc/zypp/zypp.conf
    - text:
        - solver.onlyRequires = true
        - rpm.install.excludedocs = yes
        - multiversion =
{% endif %}

{% if software.get('packages') %}
{{ macros.log('pkg', 'install_packages') }}
install_packages:
  pkg.installed:
    - pkgs: {{ software.packages }}
    - no_recommends: yes
    - includes: [product, pattern]
    - root: /mnt
{% endif %}

{% if software_config.get('minimal') %}
{{ macros.log('file', 'config_zypp_minimal') }}
config_zypp_minimal:
  file.append:
    - name: /mnt/etc/zypp/zypp.conf
    - text:
        - solver.onlyRequires = true
        - rpm.install.excludedocs = yes
        - multiversion =
{% endif %}
07070100000050000081A40000427000000032000000015F4E04F80000070A000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/software/suseconnect.sls{% import 'macros.yml' as macros %}

{% set suseconnect = pillar['suseconnect'] %}
{% set suseconnect_config = suseconnect['config'] %}

{{ macros.log('suseconnect', 'register_product') }}
register_product:
  suseconnect.registered:
    - regcode: {{ suseconnect_config['regcode'] }}
{% if suseconnect_config.get('email') %}
    - email: {{ suseconnect_config['email'] }}
{% endif %}
{% if suseconnect_config.get('url') %}
    - url: {{ suseconnect_config['url'] }}
{% endif %}
    - root: /mnt
    - require:
      - mount: mount_/mnt

{% for product in suseconnect.get('products', []) %}
  {% set regcode = suseconnect_config['regcode'] %}
  {% if product is mapping %}
    {% set regcode = product.get('regcode', regcode) %}
    {% set product = product['name'] %}
  {% endif %}
  {% if 'version' in suseconnect_config and 'arch' in suseconnect_config %}
    {% if suseconnect_config['version'] not in product %}
      {% set product = '%s/%s/%s'|format(product, suseconnect_config['version'], suseconnect_config['arch']) %}
    {% endif %}
  {% endif %}
{{ macros.log('suseconnect', 'register_' ~ product) }}
register_{{ product }}:
  suseconnect.registered:
    - regcode: {{ regcode }}
    - product: {{ product }}
{% if suseconnect_config.get('email') %}
    - email: {{ suseconnect_config['email'] }}
{% endif %}
{% if suseconnect_config.get('url') %}
    - url: {{ suseconnect_config['url'] }}
{% endif %}
    - root: /mnt
    - require:
      - mount: mount_/mnt
{% endfor %}

{% if suseconnect.get('packages') %}
{{ macros.log('pkg', 'install_packages_product') }}
install_packages_product:
  pkg.installed:
    - pkgs: {{ suseconnect.packages }}
    - no_recommends: yes
    - includes: [product, pattern]
    - root: /mnt
    - require:
        - suseconnect: register_product
{% endif %}
07070100000051000041ED0000427000000032000000075F4E04F800000000000000000000000000000000000000000000003400000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage07070100000052000081A40000427000000032000000015F4E04F80000045F000000000000000000000000000000000000004300000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/_partition.sls{% import 'macros.yml' as macros %}

{% set partitions = salt.partmod.prepare_partition_data(pillar['partitions']) %}
{% set is_uefi = grains['efi'] %}

{% for device, device_info in partitions.items() if filter(device) %}
{{ macros.log('partitioned', 'create_disk_label_' ~ device) }}
create_disk_label_{{ device }}:
  partitioned.labeled:
    - name: {{ device }}
    - label: {{ device_info.label }}

{% if device_info.pmbr_boot %}
{{ macros.log('partitioned', 'set_pmbr_boot_' ~ device) }}
set_pmbr_boot_{{ device }}:
  partitioned.disk_set:
    - name: {{ device }}
    - flag: pmbr_boot
    - enabled: yes
  {% endif %}

{% for partition in device_info.get('partitions', []) %}
{{ macros.log('partitioned', 'create_partition_' ~ partition.part_id) }}
create_partition_{{ partition.part_id }}:
  partitioned.mkparted:
    - name: {{ partition.part_id }}
    - part_type: {{ partition.part_type }}
    - fs_type: {{ partition.fs_type }}
    - start: {{ partition.start }}
    - end: {{ partition.end }}
    {% if partition.flags %}
    - flags: {{ partition.flags }}
    {% endif %}
  {% endfor %}
{% endfor %}
07070100000053000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/btrfs07070100000054000081A40000427000000032000000015F4E04F8000005DD000000000000000000000000000000000000004400000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/btrfs/fstab.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
{{ macros.log('mount', 'mount_btrfs_fstab') }}
mount_btrfs_fstab:
  mount.mounted:
    - name: /mnt
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - persist: no
  {% endif %}
{% endfor %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and info.get('subvolumes') %}
    {% set prefix = info.subvolumes.get('prefix', '') %}
    {% for subvol in info.subvolumes.subvolume %}
      {% set fs_file = '/'|path_join(subvol.path) %}
      {% set fs_mntops = 'subvol=%s'|format('/'|path_join(prefix, subvol.path)) %}
      {% if not subvol.get('copy_on_write', True) %}
        {# TODO(aplanas) nodatacow seems optional if chattr was used #}
        {% set fs_mntops = fs_mntops ~ ',nodatacow' %}
      {% endif %}
{{ macros.log('mount', 'add_fstab' ~ '_' ~ fs_file) }}
add_fstab_{{ fs_file }}:
  mount.fstab_present:
    - name: {{ device }}
    - fs_file: {{ fs_file }}
    - fs_vfstype: {{ info.filesystem }}
    - fs_mntops: {{ fs_mntops }}
    - fs_freq: 0
    - fs_passno: 0
    - mount_by: uuid
    - not_change: yes
    - config: /mnt/etc/fstab
    - require:
      - mount: mount_btrfs_fstab
    {% endfor %}
  {% endif %}
{% endfor %}

{{ macros.log('mount', 'umount_btrfs_fstab') }}
umount_btrfs_fstab:
  mount.unmounted:
    - name: /mnt
    - requires: mount_btrfs_fstab
07070100000055000081A40000427000000032000000015F4E04F80000034F000000000000000000000000000000000000004400000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/btrfs/mount.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and info.get('subvolumes') %}
    {% set prefix = info.subvolumes.get('prefix', '') %}
    {% for subvol in info.subvolumes.subvolume %}
      {% set fs_file = '/mnt'|path_join(subvol.path) %}
      {% set fs_mntops = 'subvol=%s'|format('/'|path_join(prefix, subvol.path)) %}
      {% if not subvol.get('copy_on_write', True) %}
        {% set fs_mntops = fs_mntops ~ ',nodatacow' %}
      {% endif %}
{{ macros.log('mount', 'mount_' ~ fs_file) }}
mount_{{ fs_file }}:
  mount.mounted:
    - name: {{ fs_file }}
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - mkmnt: yes
    - opts: {{ fs_mntops }}
    - persist: no
    {% endfor %}
  {% endif %}
{% endfor %}
07070100000056000081A40000427000000032000000015F4E04F8000001C4000000000000000000000000000000000000004B00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/btrfs/post_install.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and 'ro' in info.get('options', []) %}
{{ macros.log('btrfs', 'set_property_ro_' ~ info.mountpoint) }}
set_property_ro_{{ info.mountpoint }}:
  btrfs.properties:
    - name: {{ info.mountpoint }}
    - device: {{ device }}
    - use_default: yes
    - ro: yes
  {% endif %}
{% endfor %}
07070100000057000081A40000427000000032000000015F4E04F80000042B000000000000000000000000000000000000004800000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/btrfs/subvolume.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and info.get('subvolumes') %}
    {# TODO(aplanas) is prefix optional? #}
    {% set prefix = info.subvolumes.get('prefix', '') %}
    {% if prefix %}
{{ macros.log('btrfs', 'subvol_create_' ~ device ~ '_prefix') }}
subvol_create_{{ device }}_prefix:
  btrfs.subvolume_created:
    - name: '{{ prefix }}'
    - device: {{ device }}
    - set_default: yes
    - force_set_default: no
    {% endif %}

{% for subvol in info.subvolumes.subvolume %}
      {% if prefix %}
        {% set path = prefix|path_join(subvol.path) %}
      {% else %}
        {% set path = subvol.path %}
      {% endif %}
{{ macros.log('btrfs', 'subvol_create_' ~ device ~ '_' ~ subvol.path) }}
subvol_create_{{ device }}_{{ subvol.path }}:
  btrfs.subvolume_created:
    - name: '{{ path }}'
    - device: {{ device }}
    - copy_on_write: {{ subvol.get('copy_on_write', True) }}
    {% endfor %}
  {% endif %}
{% endfor %}
07070100000058000081A40000427000000032000000015F4E04F800000228000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/btrfs/umount.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
{{ macros.log('mount', 'mount_create_fstab') }}
mount_create_fstab:
  mount.mounted:
    - name: /mnt
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - persist: no

{{ macros.log('file', 'create_fstab') }}
create_fstab:
  file.managed:
    - name: /mnt/etc/fstab
    - user: root
    - group: root
    - mode: 644
    - makedirs: yes
    - dir_mode: 755
    - replace: no
    - requires: mount_create_fstab

{{ macros.log('mount', 'umount_create_fstab') }}
umount_create_fstab:
  mount.unmounted:
    - name: /mnt
    - requires: mount_create_fstab
  {% endif %}
{% endfor %}
0707010000005A000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/device0707010000005B000081A40000427000000032000000015F4E04F80000046F000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/device/fstab.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
{{ macros.log('mount', 'mount_device_fstab') }}
mount_device_fstab:
  mount.mounted:
    - name: /mnt
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - persist: no
  {% endif %}
{% endfor %}

{% for device, info in filesystems.items() %}
  {% set fs_file = 'swap' if info.filesystem == 'swap' else info.mountpoint %}
{{ macros.log('mount', 'add_fstab_' ~ fs_file) }}
add_fstab_{{ fs_file }}:
  mount.fstab_present:
    - name: {{ device }}
    - fs_file: {{ fs_file }}
    - fs_vfstype: {{ info.filesystem }}
    - fs_mntops: {{ ','.join(info.get('options', ['defaults'])) }}
    - fs_freq: 0
    - fs_passno: 0
  {% if not salt.filters.is_lvm(device) %}
    - mount_by: uuid
  {% endif %}
    - not_change: yes
    - config: /mnt/etc/fstab
    - require:
      - mount: mount_device_fstab
{% endfor %}

{{ macros.log('mount', 'umount_device_fstab') }}
umount_device_fstab:
  mount.unmounted:
    - name: /mnt
    - requires: mount_device_fstab
0707010000005C000081A40000427000000032000000015F4E04F80000033A000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/device/mount.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
{{ macros.log('mount', 'mount_/mnt') }}
mount_/mnt:
  mount.mounted:
    - name: /mnt
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - persist: no
  {% endif %}
{% endfor %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') and info.mountpoint != '/' %}
    {% set fs_file = '/mnt'|path_join(info.mountpoint[1:] if info.mountpoint.startswith('/') else info.mountpoint) %}
{{ macros.log('mount', 'mount_' ~ fs_file) }}
mount_{{ fs_file }}:
  mount.mounted:
    - name: {{ fs_file }}
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - mkmnt: yes
    - persist: no
  {% endif %}
{% endfor %}
0707010000005D000081A40000427000000032000000015F4E04F8000002CE000000000000000000000000000000000000004600000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/device/umount.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
{{ macros.log('mount', 'umount_/mnt') }}
umount_/mnt:
  mount.unmounted:
    - name: /mnt
    - requires: mount_/mnt
  {% endif %}
{% endfor %}
0707010000005E000081A40000427000000032000000015F4E04F8000001A5000000000000000000000000000000000000003F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/format.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
{{ macros.log('formatted', 'mkfs_partition_' ~ device) }}
mkfs_partition_{{ device }}:
  formatted.formatted:
    - name: {{ device }}
    - fs_type: {{ info.filesystem }}
  {% if info.filesystem in ('fat', 'vfat') and info.get('fat') %}
    - fat: {{ info.fat }}
  {% endif %}
{% endfor %}
0707010000005F000081A40000427000000032000000015F4E04F8000000A1000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/fstab.sls{% set config = pillar['config'] %}

include:
  - .create_fstab
  - .device.fstab
  - .btrfs.fstab
{% if config.get('snapper') %}
  - .snapper.fstab
{% endif %}
07070100000060000081A40000427000000032000000015F4E04F8000000FA000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/init.sls{% set software = pillar['software'] %}

include:
  - .partition
  - .raid
  - .volumes
  - .format
  - .subvolumes
{# TODO: Remove the double check (SumaForm bug) #}
{% if not software.get('image', {}).get('url') %}
  - .fstab
  - .mount
{% endif %}07070100000061000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003800000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/lvm07070100000062000081A40000427000000032000000015F4E04F8000000D0000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/lvm/software.sls{% import 'macros.yml' as macros %}

{{ macros.log('pkg', 'install_lvm2') }}
install_lvm2:
  pkg.installed:
    - name: lvm2
    - no_recommends: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
07070100000063000081A40000427000000032000000015F4E04F80000055B000000000000000000000000000000000000004300000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/lvm/volume.sls{% import 'macros.yml' as macros %}

{% set lvm = pillar.get('lvm', {}) %}

{% for group, group_info in lvm.items() %}
  {% set devices = [] %}
  {% for device in group_info['devices'] %}
    {% set info = {} %}
    {# We can store the device information inside a dict #}
    {% if device is mapping %}
      {% set info = device %}
      {% set device = device['name'] %}
    {% endif %}
  {% do devices.append(device) %}
{{ macros.log('lvm', 'create_physical_volume_' ~ device) }}
create_physical_volume_{{ device }}:
  lvm.pv_present:
    - name: {{ device }}
    {% for key, value in info.items() if key != 'name' %}
    - {{ key }}: {{ value }}
    {% endfor %}
  {% endfor %}

{{ macros.log('lvm', 'create_virtual_group_' ~ group) }}
create_virtual_group_{{ group }}:
  lvm.vg_present:
    - name: {{ group }}
    - devices: [{{ ', '.join(devices) }}]
    {% for key, value in group_info.items() if key not in ('devices', 'volumes') %}
    - {{ key }}: {{ value }}
    {% endfor %}

{% for volume in group_info['volumes'] %}
{{ macros.log('lvm', 'create_logical_volume_' ~ volume['name']) }}
create_logical_volume_{{ volume['name'] }}:
  lvm.lv_present:
    - name: {{ volume['name'] }}
    - vgname: {{ group }}
    {% for key, value in volume.items() if key not in ('name', 'vgname') %}
    - {{ key }}: {{ value }}
    {% endfor %}
  {% endfor %}
{% endfor %}
07070100000064000081A40000427000000032000000015F4E04F8000000A1000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/mount.sls{% set config = pillar['config'] %}

include:
  - .device.mount
  - .btrfs.mount
{% if config.get('snapper') %}
  - .snapper.mount
{% endif %}
  - ..chroot.mount07070100000065000081A40000427000000032000000015F4E04F80000004B000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/partition.sls{% set filter=salt.filters.is_not_raid %}
{% include './_partition.sls' %}
07070100000066000081A40000427000000032000000015F4E04F8000000CB000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/post_install.sls{% set config = pillar['config'] %}

include:
{% if config.get('snapper') %}
  - .snapper.post_install
{% endif %}
  - .btrfs.post_install
{% if not config.get('reboot', True) %}
  - .umount
{% endif %}
07070100000067000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003900000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/raid07070100000068000081A40000427000000032000000015F4E04F800000023000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/raid/init.slsinclude:
  - .mdadm
  - .partition
07070100000069000081A40000427000000032000000015F4E04F8000001AD000000000000000000000000000000000000004300000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/raid/mdadm.sls{% import 'macros.yml' as macros %}

{% set raid = pillar.get('raid', {}) %}

{% for device, info in raid.items() %}
{{ macros.log('raid', 'create_raid_' ~ device) }}
create_raid_{{ device }}:
  raid.present:
    - name: {{ device }}
    - level: {{ info.level }}
    - devices: {{ info.devices }}
  {% for key, value in info.items() if key not in ('level', 'devices') %}
    - {{ key }}: {{ value }}
  {% endfor %}
{% endfor %}
0707010000006A000081A40000427000000032000000015F4E04F800000048000000000000000000000000000000000000004700000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/raid/partition.sls{% set filter=salt.filters.is_raid %}
{% include '../_partition.sls' %}
0707010000006B000081A40000427000000032000000015F4E04F8000000E8000000000000000000000000000000000000004600000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/raid/software.sls{% import 'macros.yml' as macros %}

{{ macros.log('pkg', 'install_raid') }}
install_raid:
  pkg.installed:
    - pkgs:
      - mdadm
      - dmraid
    - no_recommends: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
0707010000006C000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper0707010000006D000081A40000427000000032000000015F4E04F800000516000000000000000000000000000000000000004600000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper/fstab.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.get('mountpoint') == '/' %}
{{ macros.log('mount', 'mount_snapper_fstab') }}
mount_snapper_fstab:
  mount.mounted:
    - name: /mnt
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - persist: no
  {% endif %}
{% endfor %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and info.mountpoint == '/' %}
    {% set prefix = info.subvolumes.get('prefix', '') %}
    {% set fs_file = '/'|path_join('.snapshots') %}
    {% set fs_mntops = 'subvol=%s'|format('/'|path_join(prefix, '.snapshots')) %}
{{ macros.log('mount', 'add_fstab_' ~ fs_file) }}
add_fstab_{{ fs_file }}:
  mount.fstab_present:
    - name: {{ device }}
    - fs_file: {{ fs_file }}
    - fs_vfstype: {{ info.filesystem }}
    - fs_mntops: {{ fs_mntops }}
    - fs_freq: 0
    - fs_passno: 0
    {% if not salt.filters.is_lvm(device) %}
    - mount_by: uuid
    {% endif %}
    - not_change: yes
    - config: /mnt/etc/fstab
    - require:
      - mount: mount_snapper_fstab
  {% endif %}
{% endfor %}

{{ macros.log('mount', 'umount_snapper_fstab') }}
umount_snapper_fstab:
  mount.unmounted:
    - name: /mnt
    - requires: mount_snapper_fstab
0707010000006E000081A40000427000000032000000015F4E04F8000000CC000000000000000000000000000000000000004F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper/grub2_mkconfig.sls{% import 'macros.yml' as macros %}

{{ macros.log('file', 'config_snapper_grub2') }}
config_snapper_grub2:
  file.append:
    - name: /mnt/etc/default/grub
    - text: SUSE_BTRFS_SNAPSHOT_BOOTING="true"
0707010000006F000081A40000427000000032000000015F4E04F80000028B000000000000000000000000000000000000004600000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper/mount.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and info.mountpoint == '/' %}
    {% set prefix = info.subvolumes.get('prefix', '') %}
    {% set fs_mntops = 'subvol=%s'|format('/'|path_join(prefix, '.snapshots')) %}
    {% set fs_file = '/mnt'|path_join('.snapshots') %}
{{ macros.log('mount', 'mount_' ~ fs_file) }}
mount_{{ fs_file }}:
  mount.mounted:
    - name: {{ fs_file }}
    - device: {{ device }}
    - fstype: {{ info.filesystem }}
    - mkmnt: no
    - opts: {{ fs_mntops }}
    - persist: no
  {% endif %}
{% endfor %}
07070100000070000081A40000427000000032000000015F4E04F800000270000000000000000000000000000000000000004D00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper/post_install.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and info.mountpoint == '/' %}
{{ macros.log('snapper_install', 'snapper_step_four_' ~ device) }}
snapper_step_four_{{ device }}:
  snapper_install.step_four:
    - root: /mnt

{{ macros.log('snapper_install', 'snapper_step_five_' ~ device) }}
snapper_step_five_{{ device }}:
  snapper_install.step_five:
    - root: /mnt
    - snapshot_type: single
    - description: 'after installation'
    - important: yes
    - cleanup: number
  {% endif %}
{% endfor %}
07070100000071000081A40000427000000032000000015F4E04F80000012D000000000000000000000000000000000000004900000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper/software.sls{% import 'macros.yml' as macros %}

{{ macros.log('pkg', 'install_snapper') }}
install_snapper:
  pkg.installed:
    - pkgs:
      - snapper
      - grub2-snapper-plugin
      - snapper-zypp-plugin
      - btrfsprogs
    - no_recommends: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
07070100000072000081A40000427000000032000000015F4E04F80000026E000000000000000000000000000000000000004A00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper/subvolume.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% for device, info in filesystems.items() %}
  {% if info.filesystem == 'btrfs' and info.mountpoint == '/' %}
{{ macros.log('snapper_install', 'snapper_step_one_' ~ device) }}
snapper_step_one_{{ device }}:
  snapper_install.step_one:
    - device: {{ device }}
    - description: 'first root filesystem'

{{ macros.log('snapper_install', 'snapper_step_two_' ~ device) }}
snapper_step_two_{{ device }}:
  snapper_install.step_two:
    - device: {{ device }}
    - prefix: "{{ info.subvolumes.get('prefix') }}"
  {% endif %}
{% endfor %}
07070100000073000081A40000427000000032000000015F4E04F80000011D000000000000000000000000000000000000004700000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/snapper/umount.sls{% import 'macros.yml' as macros %}

{% set filesystems = pillar['filesystems'] %}

{% set fs_file = '/mnt'|path_join('.snapshots') %}
{{ macros.log('mount', 'umount_' ~ fs_file) }}
umount_{{ fs_file }}:
  mount.unmounted:
    - name: {{ fs_file }}
    - requires: mount_{{ fs_file }}
07070100000074000081A40000427000000032000000015F4E04F800000145000000000000000000000000000000000000004100000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/software.sls{% set config = pillar['config'] %}

{% if pillar.get('raid') or pillar.get('lvm') or config.get('snapper') %}
include:
  {% if pillar.get('raid') %}
  - .raid.software
  {% endif %}
  {% if pillar.get('lvm') %}
  - .lvm.software
  {% endif %}
  {% if config.get('snapper') %}
  - .snapper.software
  {% endif %}
{% endif %}
07070100000075000081A40000427000000032000000015F4E04F800000085000000000000000000000000000000000000004300000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/subvolumes.sls{% set config = pillar['config'] %}

include:
  - .btrfs.subvolume
{% if config.get('snapper') %}
  - .snapper.subvolume
{% endif %}
07070100000076000081A40000427000000032000000015F4E04F8000000A6000000000000000000000000000000000000003F00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/umount.sls{% set config = pillar['config'] %}

include:
  - ..chroot.umount
{% if config.get('snapper') %}
  - .snapper.umount
{% endif %}
  - .btrfs.umount
  - .device.umount
07070100000077000081A40000427000000032000000015F4E04F800000019000000000000000000000000000000000000004000000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/volumes.slsinclude:
  - .lvm.volume
07070100000078000081A40000427000000032000000015F4E04F800000121000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/storage/wipe.sls{% import 'macros.yml' as macros %}

{% set partitions = salt.partmod.prepare_partition_data(pillar['partitions']) %}

{% for device in partitions %}
{{ macros.log('module', 'wipe_' ~ device) }}
wipe_{{ device }}:
  module.run:
    - devices.wipe:
      - device: {{ device }}
{% endfor %}07070100000079000081A40000427000000032000000015F4E04F80000056F000000000000000000000000000000000000003600000000yomi-0.0.1+git.1598948600.9a9eab0/salt/yomi/users.sls{% import 'macros.yml' as macros %}

{% set users = pillar['users'] %}

{% for user in users %}
{{ macros.log('module', 'create_user_' ~ user.username) }}
create_user_{{ user.username }}:
  module.run:
    - user.add:
      - name: {{ user.username }}
      - createhome: yes
      - root: /mnt
    - unless: grep -q '{{ user.username }}' /mnt/etc/shadow

{% if user.get('password') %}
{{ macros.log('module', 'set_password_user_' ~ user.username) }}
# We should use here the root parameter, but we move to chroot.call
# because bsc#1167909
set_password_user_{{ user.username }}:
  module.run:
    - chroot.call:
      - root: /mnt
      - function: shadow.set_password
      - name: {{ user.username }}
      - password: "'{{ user.password }}'"
      - use_usermod: yes
    - unless: grep -q '{{ user.username }}:{{ user.password }}' /mnt/etc/shadow
  {% endif %}

{% for certificate in user.get('certificates', []) %}
{{ macros.log('module', 'add_certificate_user_' ~ user.username ~ '_' ~ loop.index) }}
add_certificate_users_{{ user.username }}_{{ loop.index }}:
  module.run:
    - chroot.call:
      - root: /mnt
      - function: ssh.set_auth_key
      - user: {{ user.username }}
      - key: "'{{ certificate }}'"
    - unless: grep -q '{{ certificate }}' /mnt/{{ 'home/' if user.username != 'root' else '' }}{{ user.username }}/.ssh/authorized_keys
  {% endfor %}
{% endfor %}
0707010000007A000041ED0000427000000032000000035F4E04F800000000000000000000000000000000000000000000002800000000yomi-0.0.1+git.1598948600.9a9eab0/tests0707010000007B000081A40000427000000032000000015F4E04F800000000000000000000000000000000000000000000003400000000yomi-0.0.1+git.1598948600.9a9eab0/tests/__init__.py0707010000007C000041ED0000427000000032000000025F4E04F800000000000000000000000000000000000000000000003100000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures0707010000007D000081A40000427000000032000000015F4E04F800000905000000000000000000000000000000000000004000000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures/ay_complex.xml<?xml version="1.0"?>
<!DOCTYPE profile>
<profile xmlns="http://www.suse.com/1.0/yast2ns" xmlns:config="http://www.suse.com/1.0/configns">
  <partitioning config:type="list">
    <drive>
      <device>/dev/sda</device>
      <initialize config:type="boolean">true</initialize>
      <partitions config:type="list">
	<partition>
	  <create config:type="boolean" >false</create>
	  <crypt_fs config:type="boolean">false</crypt_fs>
	  <mount>/</mount>
	  <fstopt>
	    ro,noatime,user,data=ordered,acl,user_xattr
	  </fstopt>
	  <label>mydata</label>
	  <uuid>UUID</uuid>
	  <size>10G</size>
	  <filesystem config:type="symbol">btrfs</filesystem>
	  <mkfs_options>-I 128</mkfs_options>
	  <partition_nr config:type="integer">1</partition_nr>
	  <partition_id config:type="integer">131</partition_id>
	  <partition_type>primary</partition_type>
	  <mountby config:type="symbol">label</mountby>
	  <subvolumes config:type="list">
	    <path>tmp</path>
	    <path>opt</path>
	    <path>srv</path>
	    <path>var/crash</path>
	    <path>var/lock</path>
	    <path>var/run</path>
	    <path>var/tmp</path>
	    <path>var/spool</path>
	  </subvolumes>
	  <create_subvolumes config:type="boolean" >false</create_subvolumes>
	  <subvolumes_prefix>@</subvolumes_prefix>
	  <lv_name>opt_lv</lv_name>
	  <stripes config:type="integer">2</stripes>
	  <stripesize config:type="integer">4</stripesize>
	  <lvm_group>system</lvm_group>
	  <pool config:type="boolean">false</pool>
	  <used_pool>my_thin_pool</used_pool>
	  <raid_name>/dev/md/0</raid_name>
	  <raid_options>
	    <chunk_size>4</chunk_size>
	    <parity_algorithm>left_asymmetric</parity_algorithm>
	    <raid_type>raid1</raid_type>
	    <device_order config:type="list">
              <device>/dev/sdb2</device>
              <device>/dev/sda1</device>
            </device_order>
	  </raid_options>
	  <bcache_backing_for>/dev/bcache0</bcache_backing_for>
	  <bcache_caching_for config:type="list">
	    <listentry>/dev/bcache0</listentry>
	  </bcache_caching_for>
	  <resize config:type="boolean">false</resize>
	</partition>
      </partitions>
      <use>all</use>
      <type config:type="symbol">CT_DISK</type>
      <disklabel>gpt</disklabel>
      <enable_snapshots config:type="boolean">true</enable_snapshots>
    </drive>
  </partitioning>
</profile>
0707010000007E000081A40000427000000032000000015F4E04F8000005B5000000000000000000000000000000000000004100000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures/ay_lvm_ext3.xml<?xml version="1.0"?>
<!DOCTYPE profile>
<profile xmlns="http://www.suse.com/1.0/yast2ns" xmlns:config="http://www.suse.com/1.0/configns">
  <partitioning config:type="list">
    <drive>
      <device>/dev/sda</device>
      <partitions config:type="list">
	<partition>
	  
          <lvm_group>system</lvm_group>
          <partition_type>primary</partition_type>
	  <partition_id config:type="integer">142</partition_id>
	  <partition_nr config:type="integer">1</partition_nr>
          <size>max</size>
	</partition>
      </partitions>
      <use>all</use>
    </drive>
    <drive>
      <device>/dev/system</device>
      <is_lvm_vg config:type="boolean">true</is_lvm_vg>
      <partitions config:type="list">
        <partition>
          <filesystem config:type="symbol">ext3</filesystem>
          <lv_name>user_lv</lv_name>
          <mount>/usr</mount>
          <size>15G</size>
        </partition>
        <partition>
          <filesystem config:type="symbol">ext3</filesystem>
          <lv_name>opt_lv</lv_name>
          <mount>/opt</mount>
          <size>10G</size>
        </partition>
        <partition>
          <filesystem config:type="symbol">ext3</filesystem>
          <lv_name>var_lv</lv_name>
          <mount>/var</mount>
          <size>1G</size>
        </partition>
      </partitions>
      <pesize>4M</pesize>
      <use>all</use>
    </drive>
  </partitioning>
</profile>
0707010000007F000081A40000427000000032000000015F4E04F800000565000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures/ay_raid_ext3.xml<?xml version="1.0"?>
<!DOCTYPE profile>
<profile xmlns="http://www.suse.com/1.0/yast2ns" xmlns:config="http://www.suse.com/1.0/configns">
  <partitioning config:type="list">
    <drive>
      <device>/dev/sda</device>
      <partitions config:type="list">
	<partition>
	  <filesystem config:type="symbol">ext3</filesystem>
          <mount>/</mount>
          <size>20G</size>
	</partition>
	<partition>
          <raid_name>/dev/md/0</raid_name>
          <size>max</size>
	</partition>
      </partitions>
      <use>all</use>
    </drive>
    <drive>
      <device>/dev/sdb</device>
      <disklabel>none</disklabel>
      <partitions config:type="list">
	<partition>
          <raid_name>/dev/md/0</raid_name>
	</partition>
      </partitions>
      <use>all</use>
    </drive>
    <drive>
      <device>/dev/md/0</device>
      <partitions config:type="list">
	<partition>
	  <filesystem config:type="symbol">ext3</filesystem>
          <mount>/home</mount>
          <size>40G</size>
	</partition>
	<partition>
	  <filesystem config:type="symbol">ext3</filesystem>
          <mount>/srv</mount>
          <size>10G</size>
	</partition>
      </partitions>
      <raid_options>
	<chunk_size>4</chunk_size>
	<parity_algorithm>left_asymmetric</parity_algorithm>
	<raid_type>raid1</raid_type>
      </raid_options>
      <use>all</use>
    </drive>
  </partitioning>
</profile>
07070100000080000081A40000427000000032000000015F4E04F800000259000000000000000000000000000000000000004F00000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures/ay_raid_no_partition_ext3.xml<?xml version="1.0"?>
<!DOCTYPE profile>
<profile xmlns="http://www.suse.com/1.0/yast2ns" xmlns:config="http://www.suse.com/1.0/configns">
  <partitioning config:type="list">
    <drive>
      <device>/dev/md/0</device>
      <disklabel>none</disklabel>
      <partitions config:type="list">
	<partition>
	  <mount>/home</mount>
	  <size>40G</size>
	</partition>
      </partitions>
      <raid_options>
	<chunk_size>4</chunk_size>
	<parity_algorithm>left_asymmetric</parity_algorithm>
	<raid_type>raid1</raid_type>
      </raid_options>
      <use>all</use>
    </drive>
  </partitioning>
</profile>
07070100000081000081A40000427000000032000000015F4E04F8000006B4000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures/ay_single_btrfs.xml<?xml version="1.0"?>
<!DOCTYPE profile>
<profile xmlns="http://www.suse.com/1.0/yast2ns" xmlns:config="http://www.suse.com/1.0/configns">

<partitioning config:type="list">
    <drive>
      <device>/dev/sda</device>
      <initialize config:type="boolean">true</initialize>
      <partitions config:type="list">
	<partition>
	  <create config:type="boolean">true</create>
	  <size>1M</size>
	  <format config:type="boolean">false</format>
	  <partition_nr config:type="integer">1</partition_nr>
	</partition>
	<partition>
	  <create config:type="boolean">true</create>
	  <mount>swap</mount>
	  <size>2G</size>
	  <format config:type="boolean">true</format>
	  <filesystem config:type="symbol">swap</filesystem>
	  <partition_nr config:type="integer">2</partition_nr>
	  <partition_id config:type="integer">130</partition_id>
	</partition>
	<partition>
	  <create config:type="boolean">true</create>
	  <mount>/</mount>
	  <size>max</size>
	  <format config:type="boolean">true</format>
	  <filesystem config:type="symbol">btrfs</filesystem>
	  <partition_nr config:type="integer">3</partition_nr>
	  <partition_id config:type="integer">131</partition_id>
	  <subvolumes config:type="list">
	    <listentry>tmp</listentry>
	    <listentry>opt</listentry>
	    <listentry>srv</listentry>
	    <listentry>
	      <path>var/lib/pgsql</path>
	      <copy_on_write config:type="boolean">false</copy_on_write>
	    </listentry>
	  </subvolumes>
	  <subvolumes_prefix>@</subvolumes_prefix>
	</partition>
      </partitions>
      <use>all</use>
      <type>CT_DISK</type>
      <disklabel>gpt</disklabel>
      <enable_snapshots config:type="boolean">false</enable_snapshots>
    </drive>
  </partitioning>

</profile>
07070100000082000081A40000427000000032000000015F4E04F800003902000000000000000000000000000000000000004400000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures/ay_single_ext3.xml<?xml version="1.0"?>
<!DOCTYPE profile>
<profile xmlns="http://www.suse.com/1.0/yast2ns" xmlns:config="http://www.suse.com/1.0/configns">
  <general>
    <mode>
      <activate_systemd_default_target config:type="boolean">
	true
      </activate_systemd_default_target>
      <confirm config:type="boolean">true</confirm>
      <confirm_base_product_license config:type="boolean">
	false
      </confirm_base_product_license>
      <final_halt config:type="boolean">false</final_halt>
      <final_reboot config:type="boolean">true</final_reboot>
      <final_restart_services config:type="boolean">
	true
      </final_restart_services>
      <forceboot config:type="boolean">false</forceboot>
      <halt config:type="boolean">false</halt>
      <max_systemd_wait config:type="integer">30</max_systemd_wait>
      <ntp_sync_time_before_installation>
	0.de.pool.ntp.org
      </ntp_sync_time_before_installation>
      <second_stage config:type="boolean">true</second_stage>
    </mode>
    <proposals config:type="list">
      <proposal>partitions_proposal</proposal>
      <proposal>timezone_proposal</proposal>
      <proposal>software_proposal</proposal>
    </proposals>
    <self_update config:type="boolean">true</self_update>
    <self_update_url>
      http://example.com/updates/$arch
    </self_update_url>
    <semi-automatic config:type="list">
      <semi-automatic_entry>networking</semi-automatic_entry>
      <semi-automatic_entry>scc</semi-automatic_entry>
      <semi-automatic_entry>partitioning</semi-automatic_entry>
    </semi-automatic>
    <signature-handling>
      <accept_unsigned_file config:type="boolean">
	false
      </accept_unsigned_file>
      <accept_file_without_checksum config:type="boolean">
	false
      </accept_file_without_checksum>
      <accept_verification_failed config:type="boolean">
	false
      </accept_verification_failed>
      <accept_unknown_gpg_key config:type="boolean">
	false
      </accept_unknown_gpg_key>
      <accept_non_trusted_gpg_key config:type="boolean">
	false
      </accept_non_trusted_gpg_key>
      <import_gpg_key config:type="boolean">
	false
      </import_gpg_key>
    </signature-handling>
    <storage>
      <start_multipath config:type="boolean">false</start_multipath>
    </storage>
    <wait>
      <pre-modules config:type="list">
	<module>
	  <name>networking</name>
	  <sleep>
	    <time config:type="integer">10</time>
	    <feedback config:type="boolean">true</feedback>
	  </sleep>
	  <script>
	    <source>echo foo</source>
	    <debug config:type="boolean">false</debug>
	  </script>
	</module>
      </pre-modules>
      <post-modules config:type="list">
	<module>
	  <name>networking</name>
	  <sleep>
	    <time config:type="integer">10</time>
	    <feedback config:type="boolean">true</feedback>
	  </sleep>
	  <script>
	    <source>echo foo</source>
	    <debug config:type="boolean">false</debug>
	  </script>
	</module>
      </post-modules>
    </wait>
    <cio_ignore config:type="boolean">false</cio_ignore>
  </general>

<suse_register>
    <do_registration config:type="boolean">true</do_registration>
    <email>tux@example.com</email>
    <reg_code>MY_SECRET_REGCODE</reg_code>
    <install_updates config:type="boolean">true</install_updates>
    <slp_discovery config:type="boolean">false</slp_discovery>
    <reg_server>
      https://smt.example.com
    </reg_server>
    <reg_server_cert_fingerprint_type>
      SHA1
    </reg_server_cert_fingerprint_type>
    <reg_server_cert_fingerprint>
      01:AB...:EF
    </reg_server_cert_fingerprint>
    <reg_server_cert>
      http://smt.example.com/smt.crt
    </reg_server_cert>
    <addons config:type="list">
      <addon>
	<name>sle-module-basesystem</name>
	<version>15.1</version>
	<arch>x86_64</arch>
      </addon>
    </addons>
  </suse_register>

<bootloader>
    <loader_type>
      grub2-efi
    </loader_type>
    <global>
      <activate config:type="boolean">true</activate>
      <append>nomodeset vga=0x317</append>
      <boot_boot>false</boot_boot>
      <boot_custom>/dev/sda</boot_custom>
      <boot_extended>false</boot_extended>
      <boot_mbr>false</boot_mbr>
      <boot_root>false</boot_root>
      <generic_mbr config:type="boolean">false</generic_mbr>
      <gfxmode>1280x1024x24</gfxmode>
      <os_prober config:type="boolean">false</os_prober>
      <cpu_mitigations>auto</cpu_mitigations>
      <suse_btrfs config:type="boolean">true</suse_btrfs>
      <serial>
	serial --speed=115200 --unit=0 --word=8 --parity=no --stop=1
      </serial>
      <terminal>serial</terminal>
      <timeout config:type="integer">10</timeout>
      <trusted_boot config:type="boolean">true</trusted_boot>
      <vgamode>0x317</vgamode>
      <xen_append>nomodeset vga=0x317</xen_append>
      <xen_kernel_append>dom0_mem=768M</xen_kernel_append>
    </global>
    <device_map config:type="list">
      <device_map_entry>
	<firmware>hd0</firmware>
	<linux>/dev/disk/by-id/ata-ST3500418AS_6VM23FX0</linux>
      </device_map_entry>
    </device_map>
  </bootloader>

<partitioning config:type="list">
    <drive>
      <device>/dev/sda</device>
      <initialize config:type="boolean">true</initialize>
      <partitions config:type="list">
	<partition>
	  <create config:type="boolean">true</create>
	  <size>1M</size>
	  <format config:type="boolean">false</format>
	  <partition_nr config:type="integer">1</partition_nr>
	</partition>
	<partition>
	  <create config:type="boolean">true</create>
	  <mount>swap</mount>
	  <size>2G</size>
	  <format config:type="boolean">true</format>
	  <filesystem config:type="symbol">swap</filesystem>
	  <partition_nr config:type="integer">2</partition_nr>
	  <partition_id config:type="integer">130</partition_id>
	</partition>
	<partition>
	  <create config:type="boolean">true</create>
	  <mount>/</mount>
	  <size>max</size>
	  <format config:type="boolean">true</format>
	  <filesystem config:type="symbol">ext3</filesystem>
	  <partition_nr config:type="integer">3</partition_nr>
	  <partition_id config:type="integer">131</partition_id>
	</partition>
      </partitions>
      <use>all</use>
      <type>CT_DISK</type>
      <disklabel>gpt</disklabel>
      <enable_snapshots config:type="boolean">false</enable_snapshots>
    </drive>
  </partitioning>

<timezone>
    <hwclock>UTC</hwclock>
    <timezone>Europe/Berlin</timezone>
  </timezone>

<keyboard>
    <keymap>german</keymap>
  </keyboard>

<software>
    <products config:type="list">
      <product>SLED</product>
    </products>
    <patterns config:type="list">
      <pattern>directory_server</pattern>
    </patterns>
    <packages config:type="list">
      <package>apache</package>
      <package>postfix</package>
    </packages>
    <remove-packages config:type="list">
      <package>postfix</package>
    </remove-packages>
    <do_online_update config:type="boolean">true</do_online_update>
    <kernel>kernel-default</kernel>
    <install_recommended config:type="boolean">false</install_recommended>
    <post-packages config:type="list">
      <package>yast2-cim</package>
    </post-packages>
    <post-patterns config:type="list">
      <pattern>apparmor</pattern>
    </post-patterns>
  </software>

<add-on>
    <add_on_products config:type="list">
      <listentry>
	<media_url>cd:///sdk</media_url>
	<product>sle-sdk</product>
	<alias>SLES SDK</alias>
	<product_dir>/</product_dir>
	<priority config:type="integer">20</priority>
	<ask_on_error config:type="boolean">false</ask_on_error>
	<confirm_license config:type="boolean">false</confirm_license>
	<name>SUSE Linux Enterprise Software Development Kit</name>
      </listentry>
    </add_on_products>
    <add_on_others config:type="list">
      <listentry>
	<media_url>https://download.opensuse.org/repositories/YaST:/Head/openSUSE_Leap_15.1/</media_url>
	<alias>yast2_head</alias>
	<priority config:type="integer">30</priority>
	<name>Latest YaST2 packages from OBS</name>
      </listentry>
    </add_on_others>
  </add-on>

<services-manager>
    <default_target>multi-user</default_target>
    <services>
      <disable config:type="list">
	<service>libvirtd</service>
      </disable>
      <enable config:type="list">
	<service>sshd</service>
      </enable>
      <on_demand config:type="list">
	<service>cups</service>
      </on_demand>
    </services>
  </services-manager>

<networking>
    <dns>
      <dhcp_hostname config:type="boolean">true</dhcp_hostname>
      <domain>site</domain>
      <hostname>linux-bqua</hostname>
      <nameservers config:type="list">
	<nameserver>192.168.1.116</nameserver>
	<nameserver>192.168.1.117</nameserver>
	<nameserver>192.168.1.118</nameserver>
      </nameservers>
      <resolv_conf_policy>auto</resolv_conf_policy>
      <searchlist config:type="list">
	<search>example.com</search>
	<search>example.net</search>
      </searchlist>
      <write_hostname config:type="boolean">false</write_hostname>
    </dns>
    <interfaces config:type="list">
      <interface>
	<bootproto>dhcp</bootproto>
	<device>eth0</device>
	<startmode>auto</startmode>
      </interface>
      <interface>
	<bootproto>static</bootproto>
	<broadcast>127.255.255.255</broadcast>
	<device>lo</device>
	<firewall>no</firewall>
	<ipaddr>127.0.0.1</ipaddr>
	<netmask>255.0.0.0</netmask>
	<network>127.0.0.0</network>
	<prefixlen>8</prefixlen>
	<startmode>nfsroot</startmode>
	<usercontrol>no</usercontrol>
      </interface>
    </interfaces>
    <ipv6 config:type="boolean">true</ipv6>
    <keep_install_network config:type="boolean">false</keep_install_network>
    <managed config:type="boolean">false</managed>       ###### NetworkManager?
    <net-udev config:type="list">
      <rule>
	<name>eth0</name>
	<rule>ATTR{address}</rule>
	<value>00:30:6E:08:EC:80</value>
      </rule>
    </net-udev>
    <s390-devices config:type="list">
      <listentry>
	<chanids>0.0.0800 0.0.0801 0.0.0802</chanids>
	<type>qeth</type>
      </listentry>
    </s390-devices>
    <routing>
      <ipv4_forward config:type="boolean">false</ipv4_forward>
      <ipv6_forward config:type="boolean">false</ipv6_forward>
      <routes config:type="list">
	<route>
          <destination>192.168.2.1</destination>
          <device>eth0</device>
          <extrapara>foo</extrapara>
          <gateway>-</gateway>
          <netmask>-</netmask>
	</route>
	<route>
          <destination>default</destination>
          <device>eth0</device>
          <gateway>192.168.1.1</gateway>
          <netmask>-</netmask>
	</route>
	<route>
          <destination>default</destination>
          <device>lo</device>
          <gateway>192.168.5.1</gateway>
          <netmask>-</netmask>
	</route>
      </routes>
    </routing>
  </networking>

<users config:type="list">
    <user>
      <username>root</username>
      <user_password>password</user_password>
      <uid>1001</uid>
      <gid>100</gid>
      <encrypted config:type="boolean">false</encrypted>
      <fullname>Root User</fullname>
      <authorized_keys config:type="list">
	<listentry>command="/opt/login.sh" ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDKLt1vnW2vTJpBp3VK91rFsBvpY97NljsVLdgUrlPbZ/L51FerQQ+djQ/ivDASQjO+567nMGqfYGFA/De1EGMMEoeShza67qjNi14L1HBGgVojaNajMR/NI2d1kDyvsgRy7D7FT5UGGUNT0dlcSD3b85zwgHeYLidgcGIoKeRi7HpVDOOTyhwUv4sq3ubrPCWARgPeOLdVFa9clC8PTZdxSeKp4jpNjIHEyREPin2Un1luCIPWrOYyym7aRJEPopCEqBA9HvfwpbuwBI5F0uIWZgSQLfpwW86599fBo/PvMDa96DpxH1VlzJlAIHQsMkMHbsCazPNC0++Kp5ZVERiH root@example.net</listentry>
      </authorized_keys>
    </user>
    <user>
      <username>tux</username>
      <user_password>password</user_password>
      <uid>1002</uid>
      <gid>100</gid>
      <encrypted config:type="boolean">false</encrypted>
      <fullname>Plain User</fullname>
      <home>/Users/plain</home>
      <password_settings>
	<max>120</max>
	<inact>5</inact>
      </password_settings>
    </user>
  </users>

<groups config:type="list">
    <group>
      <gid>100</gid>
      <groupname>users</groupname>
      <userlist>bob,alice</userlist>
    </group>
  </groups>

<login_settings>
    <autologin_user>vagrant</autologin_user>
    <password_less_login config:type="boolean">true</password_less_login>
  </login_settings>

<sysconfig config:type="list" >
    <sysconfig_entry>
      <sysconfig_key>XNTPD_INITIAL_NTPDATE</sysconfig_key>
      <sysconfig_path>/etc/sysconfig/xntp</sysconfig_path>
      <sysconfig_value>ntp.host.com</sysconfig_value>
    </sysconfig_entry>
    <sysconfig_entry>
      <sysconfig_key>HTTP_PROXY</sysconfig_key>
      <sysconfig_path>/etc/sysconfig/proxy</sysconfig_path>
      <sysconfig_value>proxy.host.com:3128</sysconfig_value>
    </sysconfig_entry>
    <sysconfig_entry>
      <sysconfig_key>FTP_PROXY</sysconfig_key>
      <sysconfig_path>/etc/sysconfig/proxy</sysconfig_path>
      <sysconfig_value>proxy.host.com:3128</sysconfig_value>
    </sysconfig_entry>
  </sysconfig>

<firewall>
    <enable_firewall>true</enable_firewall>
    <log_denied_packets>all</log_denied_packets>
    <default_zone>external</default_zone>
    <zones config:type="list">
      <zone>
	<name>public</name>
	<interfaces config:type="list">
          <interface>eth0</interface>
	</interfaces>
	<services config:type="list">
          <service>ssh</service>
          <service>dhcp</service>
          <service>dhcpv6</service>
          <service>samba</service>
          <service>vnc-server</service>
	</services>
	<ports config:type="list">
          <port>21/udp</port>
          <port>22/udp</port>
          <port>80/tcp</port>
          <port>443/tcp</port>
          <port>8080/tcp</port>
	</ports>
      </zone>
      <zone>
	<name>dmz</name>
	<interfaces config:type="list">
          <interface>eth1</interface>
	</interfaces>
      </zone>
    </zones>
  </firewall>

</profile>
07070100000083000081A40000427000000032000000015F4E04F800000983000000000000000000000000000000000000004500000000yomi-0.0.1+git.1598948600.9a9eab0/tests/fixtures/list_extensions.txt[1mAVAILABLE EXTENSIONS AND MODULES[0m

[1mBasesystem Module 15 SP2 x86_64[0m [33m(Activated)[0m
    Deactivate with: SUSEConnect [31m-d[0m -p sle-module-basesystem/15.2/x86_64

[1mContainers Module 15 SP2 x86_64[0m
        Activate with: SUSEConnect -p sle-module-containers/15.2/x86_64

[1mDesktop Applications Module 15 SP2 x86_64[0m
        Activate with: SUSEConnect -p sle-module-desktop-applications/15.2/x86_64

[1mDevelopment Tools Module 15 SP2 x86_64[0m
            Activate with: SUSEConnect -p sle-module-development-tools/15.2/x86_64

[1mSUSE Linux Enterprise Workstation Extension 15 SP2 x86_64 (ALPHA)[0m
            Activate with: SUSEConnect -p sle-we/15.2/x86_64 -r [32m[1mADDITIONAL REGCODE[0m

[1mPython 2 Module 15 SP2 x86_64[0m
        Activate with: SUSEConnect -p sle-module-python2/15.2/x86_64

[1mSUSE Linux Enterprise Live Patching 15 SP2 x86_64 (ALPHA)[0m
        Activate with: SUSEConnect -p sle-module-live-patching/15.2/x86_64 -r [32m[1mADDITIONAL REGCODE[0m

[1mSUSE Package Hub 15 SP2 x86_64[0m
        Activate with: SUSEConnect -p PackageHub/15.2/x86_64

[1mServer Applications Module 15 SP2 x86_64[0m [33m(Activated)[0m
        Deactivate with: SUSEConnect [31m-d[0m -p sle-module-server-applications/15.2/x86_64

[1mLegacy Module 15 SP2 x86_64[0m
            Activate with: SUSEConnect -p sle-module-legacy/15.2/x86_64

[1mPublic Cloud Module 15 SP2 x86_64[0m
            Activate with: SUSEConnect -p sle-module-public-cloud/15.2/x86_64

[1mSUSE Linux Enterprise High Availability Extension 15 SP2 x86_64 (ALPHA)[0m
            Activate with: SUSEConnect -p sle-ha/15.2/x86_64 -r [32m[1mADDITIONAL REGCODE[0m

[1mWeb and Scripting Module 15 SP2 x86_64[0m
            Activate with: SUSEConnect -p sle-module-web-scripting/15.2/x86_64

[1mTransactional Server Module 15 SP2 x86_64[0m
        Activate with: SUSEConnect -p sle-module-transactional-server/15.2/x86_64

[1mREMARKS[0m

[31m(Not available)[0m The module/extension is [1mnot[0m enabled on your RMT/SMT
[33m(Activated)[0m     The module/extension is activated on your system

[1mMORE INFORMATION[0m

You can find more information about available modules here:
https://www.suse.com/documentation/sles-15/singlehtml/art_modules/art_modules.html
07070100000084000081ED0000427000000032000000015F4E04F8000006FB000000000000000000000000000000000000003500000000yomi-0.0.1+git.1598948600.9a9eab0/tests/run_tests.sh#! /bin/bash

#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

# Setup the environment so the Python modules living in salt/_* can be
# found.

cd "$(dirname "${BASH_SOURCE[0]}")"

test_env=$(mktemp -d -t tmp.XXXX)
tear_down() {
    rm -fr "$test_env"
}

trap tear_down EXIT

# Create the temporary Python modules, that once added in the
# PYTHON_PATH can be found and imported
touch "$test_env"/__init__.py
for module in modules states grains utils; do
    mkdir "$test_env"/"$module"
    touch "$test_env"/"$module"/__init__.py
    [ "$(ls -A ../salt/_"$module")" ] && ln -sr ../salt/_"$module"/* "$test_env"/"$module"/
done

for binary in autoyast2yomi monitor; do
    ln -sr ../"$binary" "$test_env"/"$binary".py
done

if [ -z $PYTHONPATH ]; then
    export PYTHONPATH="$test_env":"$test_env"/utils:.
else
    export PYTHONPATH="$PATHONPATH":"$test_env":"$test_env"/utils:.
fi

if [ -z "$*" ]; then
    python3 -m unittest discover
else
    python3 -m unittest "$@"
fi
07070100000085000081A40000427000000032000000015F4E04F800005A1B000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_autoyast2yomi.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import os.path
import unittest
from unittest.mock import patch
import xml.etree.ElementTree as ET

import autoyast2yomi

class AutoYaST2YomiTestCase(unittest.TestCase):
    def _parse_xml(self, name):
        name = os.path.join(os.path.dirname(__file__), "fixtures/{}".format(name))
        return ET.parse(name)

def setUp(self):
        self.maxDiff = None

def test__find(self):
        control = self._parse_xml("ay_single_ext3.xml")
        general = autoyast2yomi.Convert._find(control.getroot(), "general")
        self.assertEqual(general.tag, "{http://www.suse.com/1.0/yast2ns}general")

non_existent = autoyast2yomi.Convert._find(control, "non-existent")
        self.assertIsNone(non_existent)

def test__get_tag(self):
        control = ET.fromstring('<a xmlns="http://www.suse.com/1.0/yast2ns"><b/></a>')
        self.assertEqual(autoyast2yomi.Convert._get_tag(control[0]), "b")

def test__get_type(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns" '
            'xmlns:config="http://www.suse.com/1.0/configns">'
            '<b config:type="integer"/></a>'
        )
        self.assertEqual(autoyast2yomi.Convert._get_type(control[0]), "integer")

control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns" '
            'xmlns:config="http://www.suse.com/1.0/configns">'
            "<b/></a>"
        )
        self.assertIsNone(autoyast2yomi.Convert._get_type(control[0]))

def test__get_text(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns"><b>text</b></a>'
        )
        value = autoyast2yomi.Convert._get_text(control[0])
        self.assertEqual(value, "text")

non_text = autoyast2yomi.Convert._get_text(None)
        self.assertIsNone(non_text)

def test__get_bool(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns"><b>true</b>' "<c>false</c></a>"
        )
        value = autoyast2yomi.Convert._get_bool(control[0])
        self.assertTrue(value)

value = autoyast2yomi.Convert._get_bool(control[1])
        self.assertFalse(value)

non_bool = autoyast2yomi.Convert._get_bool(control)
        self.assertIsNone(non_bool)

def test__get_int(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns"><b>0</b>' "<c>1</c></a>"
        )
        value = autoyast2yomi.Convert._get_int(control[0])
        self.assertEqual(value, 0)

value = autoyast2yomi.Convert._get_int(control[1])
        self.assertEqual(value, 1)

non_int = autoyast2yomi.Convert._get_int(control)
        self.assertIsNone(non_int)

def test__parse_single_text(self):
        control = ET.fromstring('<a xmlns="http://www.suse.com/1.0/yast2ns">text</a>')
        self.assertEqual(autoyast2yomi.Convert._parse(control), {"a": "text"})

def test__parse_single_bool(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns" '
            'xmlns:config="http://www.suse.com/1.0/configns" '
            'config:type="boolean">true</a>'
        )
        self.assertEqual(autoyast2yomi.Convert._parse(control), {"a": True})

def test__parse_single_int(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns" '
            'xmlns:config="http://www.suse.com/1.0/configns" '
            'config:type="integer">10</a>'
        )
        self.assertEqual(autoyast2yomi.Convert._parse(control), {"a": 10})

def test__parse_single_list(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns" '
            'xmlns:config="http://www.suse.com/1.0/configns" '
            'config:type="list"><b>one</b><b>two</b></a>'
        )
        self.assertEqual(autoyast2yomi.Convert._parse(control), {"a": ["one", "two"]})

def test__parse_single_dict(self):
        control = ET.fromstring(
            '<a xmlns="http://www.suse.com/1.0/yast2ns">' "<b>text</b><c>other</c></a>"
        )
        self.assertEqual(
            autoyast2yomi.Convert._parse(control), {"a": {"b": "text", "c": "other"}}
        )

def test__parse_complex(self):
        control = self._parse_xml("ay_complex.xml").getroot()
        self.assertEqual(
            autoyast2yomi.Convert._parse(control),
            {
                "profile": {
                    "partitioning": [
                        {
                            "device": "/dev/sda",
                            "disklabel": "gpt",
                            "enable_snapshots": True,
                            "initialize": True,
                            "partitions": [
                                {
                                    "bcache_backing_for": "/dev/bcache0",
                                    "bcache_caching_for": ["/dev/bcache0"],
                                    "create": False,
                                    "create_subvolumes": False,
                                    "crypt_fs": False,
                                    "filesystem": "btrfs",
                                    "fstopt": (
                                        "ro,noatime,user,data=ordered," "acl,user_xattr"
                                    ),
                                    "label": "mydata",
                                    "lv_name": "opt_lv",
                                    "lvm_group": "system",
                                    "mkfs_options": "-I 128",
                                    "mount": "/",
                                    "mountby": "label",
                                    "partition_id": 131,
                                    "partition_nr": 1,
                                    "partition_type": "primary",
                                    "pool": False,
                                    "raid_name": "/dev/md/0",
                                    "raid_options": {
                                        "chunk_size": "4",
                                        "device_order": ["/dev/sdb2", "/dev/sda1"],
                                        "parity_algorithm": "left_asymmetric",
                                        "raid_type": "raid1",
                                    },
                                    "resize": False,
                                    "size": "10G",
                                    "stripes": 2,
                                    "stripesize": 4,
                                    "subvolumes": [
                                        "tmp",
                                        "opt",
                                        "srv",
                                        "var/crash",
                                        "var/lock",
                                        "var/run",
                                        "var/tmp",
                                        "var/spool",
                                    ],
                                    "subvolumes_prefix": "@",
                                    "used_pool": "my_thin_pool",
                                    "uuid": "UUID",
                                }
                            ],
                            "type": "CT_DISK",
                            "use": "all",
                        }
                    ]
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_config_single_ext3(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_config()
        self.assertEqual(
            convert.pillar,
            {
                "config": {
                    "events": True,
                    "reboot": True,
                    "snapper": False,
                    "locale": "en_GB",
                    "keymap": "de-nodeadkeys",
                    "timezone": "Europe/Berlin",
                    "hostname": "linux-bqua",
                    "target": "multi-user",
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_partitions_single_ext3(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_partitions()
        self.assertEqual(
            convert.pillar,
            {
                "partitions": {
                    "devices": {
                        "/dev/sda": {
                            "label": "gpt",
                            "partitions": [
                                {"number": 1, "size": "1M", "type": "boot"},
                                {"number": 2, "size": "2G", "type": "swap"},
                                {"number": 3, "size": "rest", "type": "linux"},
                            ],
                        }
                    }
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_partitions_lvm_ext3(self, logging):
        control = self._parse_xml("ay_lvm_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_partitions()
        self.assertEqual(
            convert.pillar,
            {
                "partitions": {
                    "devices": {
                        "/dev/sda": {
                            "label": "gpt",
                            "partitions": [
                                {"number": 1, "size": "rest", "type": "lvm"}
                            ],
                        }
                    }
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_partitions_raid_ext3(self, logging):
        control = self._parse_xml("ay_raid_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_partitions()
        self.assertEqual(
            convert.pillar,
            {
                "partitions": {
                    "devices": {
                        "/dev/sda": {
                            "label": "gpt",
                            "partitions": [
                                {"number": 1, "size": "20G", "type": "linux"},
                                {"number": 2, "size": "rest", "type": "raid"},
                            ],
                        },
                        "/dev/sdb": {
                            "partitions": [
                                {"number": 1, "size": "rest", "type": "raid"},
                            ]
                        },
                        "/dev/md/0": {
                            "partitions": [
                                {"number": 1, "size": "40G", "type": "linux"},
                                {"number": 2, "size": "10G", "type": "linux"},
                            ]
                        },
                    }
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_lvm_ext3(self, logging):
        control = self._parse_xml("ay_lvm_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_lvm()
        self.assertEqual(
            convert.pillar,
            {
                "lvm": {
                    "system": {
                        "devices": ["/dev/sda1"],
                        "physicalextentsize": "4M",
                        "volumes": [
                            {"name": "user_lv", "size": "15G"},
                            {"name": "opt_lv", "size": "10G"},
                            {"name": "var_lv", "size": "1G"},
                        ],
                    }
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_raid_ext3(self, logging):
        control = self._parse_xml("ay_raid_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_raid()
        self.assertEqual(
            convert.pillar,
            {
                "raid": {
                    "/dev/md/0": {
                        "level": "raid1",
                        "devices": ["/dev/sda2", "/dev/sdb1"],
                        "chunk": "4",
                        "parity": "left-asymmetric",
                    }
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_filesystems_single_ext3(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_filesystems()
        self.assertEqual(
            convert.pillar,
            {
                "filesystems": {
                    "/dev/sda2": {"filesystem": "swap", "mountpoint": "swap"},
                    "/dev/sda3": {"filesystem": "ext3", "mountpoint": "/"},
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_filesystems_single_btrfs(self, logging):
        control = self._parse_xml("ay_single_btrfs.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_filesystems()
        self.assertEqual(
            convert.pillar,
            {
                "filesystems": {
                    "/dev/sda2": {"filesystem": "swap", "mountpoint": "swap"},
                    "/dev/sda3": {
                        "filesystem": "btrfs",
                        "mountpoint": "/",
                        "subvolumes": {
                            "prefix": "@",
                            "subvolume": [
                                {"path": "tmp"},
                                {"path": "opt"},
                                {"path": "srv"},
                                {"path": "var/lib/pgsql", "copy_on_write": False},
                            ],
                        },
                    },
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_filesystems_lvm_ext3(self, logging):
        control = self._parse_xml("ay_lvm_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_filesystems()
        self.assertEqual(
            convert.pillar,
            {
                "filesystems": {
                    "/dev/system/user_lv": {
                        "filesystem": "ext3",
                        "mountpoint": "/usr",
                    },
                    "/dev/system/opt_lv": {"filesystem": "ext3", "mountpoint": "/opt"},
                    "/dev/system/var_lv": {"filesystem": "ext3", "mountpoint": "/var"},
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_filesystems_raid_ext3(self, logging):
        control = self._parse_xml("ay_raid_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_filesystems()
        self.assertEqual(
            convert.pillar,
            {
                "filesystems": {
                    "/dev/sda1": {"filesystem": "ext3", "mountpoint": "/"},
                    "/dev/md/0p1": {"filesystem": "ext3", "mountpoint": "/home"},
                    "/dev/md/0p2": {"filesystem": "ext3", "mountpoint": "/srv"},
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_bootloader(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_bootloader()
        self.assertEqual(
            convert.pillar,
            {
                "bootloader": {
                    "device": "/dev/sda",
                    "timeout": 10,
                    "kernel": (
                        "splash=silent quiet nomodeset vga=0x317 "
                        "noibrs noibpb nopti nospectre_v2 nospectre_v1 "
                        "l1tf=off nospec_store_bypass_disable "
                        "no_stf_barrier mds=off mitigations=off"
                    ),
                    "terminal": "serial",
                    "serial_command": (
                        "serial --speed=115200 --unit=0 "
                        "--word=8 --parity=no --stop=1"
                    ),
                    "gfxmode": "1280x1024x24",
                    "theme": True,
                    "disable_os_prober": True,
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_software(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_software()
        self.assertEqual(
            convert.pillar,
            {
                "software": {
                    "config": {"minimal": True},
                    "repositories": {
                        "SLES SDK": "cd:///sdk",
                        "yast2_head": (
                            "https://download.opensuse.org/repositories"
                            "/YaST:/Head/openSUSE_Leap_15.1/"
                        ),
                    },
                    "packages": [
                        "product:SLED",
                        "pattern:directory_server",
                        "apache",
                        "postfix",
                        "kernel-default",
                    ],
                }
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_suseconnect(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_suseconnect()
        self.assertEqual(
            convert.pillar,
            {
                "suseconnect": {
                    "config": {
                        "regcode": "MY_SECRET_REGCODE",
                        "email": "tux@example.com",
                        "url": "https://smt.example.com",
                    },
                    "products": ["sle-module-basesystem/15.1/x86_64"],
                    "packages": ["pattern:apparmor", "yast2-cim"],
                },
            },
        )

@patch("autoyast2yomi.logging")
    def test__convert_salt_minion(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_salt_minion()
        self.assertEqual(convert.pillar, {"salt-minion": {"configure": True}})

@patch("autoyast2yomi.logging")
    def test__convert_services(self, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        convert._convert_services()
        self.assertEqual(
            convert.pillar,
            {
                "services": {
                    "enabled": ["sshd.service", "cups.socket"],
                    "disabled": ["libvirtd.service", "cups.service"],
                }
            },
        )

def test__password(self):
        self.assertEqual(autoyast2yomi.Convert._password({}), None)
        self.assertEqual(
            autoyast2yomi.Convert._password(
                {"user_password": "linux"}, salt="$1$wYJUgpM5"
            ),
            "$1$wYJUgpM5$RXMMeASDc035eX.NbYWFl0",
        )
        self.assertEqual(
            autoyast2yomi.Convert._password(
                {
                    "user_password": "$1$wYJUgpM5$RXMMeASDc035eX.NbYWFl0",
                    "encrypted": True,
                }
            ),
            "$1$wYJUgpM5$RXMMeASDc035eX.NbYWFl0",
        )

@patch("autoyast2yomi.logging")
    @patch("autoyast2yomi.Convert._password")
    def test__convert_users(self, _password, logging):
        control = self._parse_xml("ay_single_ext3.xml")
        convert = autoyast2yomi.Convert(control)
        convert._control = autoyast2yomi.Convert._parse(control.getroot())
        _password.return_value = "<hash>"
        convert._convert_users()
        self.assertEqual(
            convert.pillar,
            {
                "users": [
                    {
                        "username": "root",
                        "password": "<hash>",
                        "certificates": [
                            (
                                "AAAAB3NzaC1yc2EAAAADAQABAAABAQDKLt1vnW2vTJpBp3VK91"
                                "rFsBvpY97NljsVLdgUrlPbZ/L51FerQQ+djQ/ivDASQjO+567n"
                                "MGqfYGFA/De1EGMMEoeShza67qjNi14L1HBGgVojaNajMR/NI2"
                                "d1kDyvsgRy7D7FT5UGGUNT0dlcSD3b85zwgHeYLidgcGIoKeRi"
                                "7HpVDOOTyhwUv4sq3ubrPCWARgPeOLdVFa9clC8PTZdxSeKp4j"
                                "pNjIHEyREPin2Un1luCIPWrOYyym7aRJEPopCEqBA9Hvfwpbuw"
                                "BI5F0uIWZgSQLfpwW86599fBo/PvMDa96DpxH1VlzJlAIHQsMk"
                                "MHbsCazPNC0++Kp5ZVERiH"
                            )
                        ],
                    },
                    {"username": "tux", "password": "<hash>"},
                ]
            },
        )
07070100000086000081A40000427000000032000000015F4E04F8000101DE000000000000000000000000000000000000003800000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_devices.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import textwrap
import unittest
from unittest.mock import patch

from modules import devices

class DevicesTestCase(unittest.TestCase):
    def test_udev(self):
        self.assertEqual(devices._udev({"A": {"B": 1}}, "a.b"), 1)
        self.assertEqual(devices._udev({"A": {"B": 1}}, "A.B"), 1)
        self.assertEqual(devices._udev({"A": {"B": 1}}, "a.c"), "n/a")
        self.assertEqual(devices._udev({"A": [1, 2]}, "a.b"), "n/a")
        self.assertEqual(devices._udev({"A": {"B": 1}}, ""), {"A": {"B": 1}})

def test_match(self):
        self.assertTrue(devices._match({"A": {"B": 1}}, {"a.b": 1}))
        self.assertFalse(devices._match({"A": {"B": 1}}, {"a.b": 2}))
        self.assertTrue(devices._match({"A": {"B": 1}}, {"a.b": [1, 2]}))
        self.assertFalse(devices._match({"A": {"B": 1}}, {"a.b": [2, 3]}))
        self.assertTrue(devices._match({"A": {"B": [1, 2]}}, {"a.b": 1}))
        self.assertTrue(devices._match({"A": {"B": [1, 2]}}, {"a.b": [1, 3]}))
        self.assertFalse(devices._match({"A": {"B": [1, 2]}}, {"a.b": [3, 4]}))
        self.assertTrue(devices._match({"A": 1}, {}))

@patch("modules.devices.__grains__")
    @patch("modules.devices.__salt__")
    def test_devices(self, __salt__, __grains__):
        cdrom = {
            "S": ["dvd", "cdrom"],
            "E": {"ID_BUS": "ata"},
        }
        usb = {
            "E": {"ID_BUS": "usb"},
        }
        hd = {
            "E": {"ID_BUS": "ata"},
        }

__grains__.__getitem__.return_value = ["sda", "sdb", "sr0"]
        __salt__.__getitem__.return_value = lambda d: {
            "sda": hd,
            "sdb": usb,
            "sr0": cdrom,
        }[d]

self.assertEqual(devices.filter_({"e.id_bus": "ata"}, {}), ["sda", "sr0"])
        self.assertEqual(devices.filter_({"e.id_bus": "usb"}, {}), ["sdb"])
        self.assertEqual(
            devices.filter_({"e.id_bus": "ata"}, {"s": ["cdrom"]}), ["sda"]
        )

def test__hwinfo_parse_short(self):
        hwinfo = textwrap.dedent(
            """
            cpu:
                                   QEMU Virtual CPU version 2.5+, 3591 MHz
            keyboard:
              /dev/input/event0    AT Translated Set 2 keyboard
            mouse:
              /dev/input/mice      VirtualPS/2 VMware VMMouse
              /dev/input/mice      VirtualPS/2 VMware VMMouse
            graphics card:
                                   VGA compatible controller
            storage:
                                   Floppy disk controller
                                   Red Hat Qemu virtual machine
            network:
              ens3                 Virtio Ethernet Card 0
            network interface:
              lo                   Loopback network interface
              ens3                 Ethernet network interface
            disk:
              /dev/fd0             Disk
              /dev/sda             QEMU HARDDISK
            cdrom:
              /dev/sr0             QEMU DVD-ROM
            floppy:
              /dev/fd0             Floppy Disk
            bios:
                                   BIOS
            bridge:
                                   Red Hat Qemu virtual machine
                                   Red Hat Qemu virtual machine
                                   Red Hat Qemu virtual machine
            memory:
                                   Main Memory
            unknown:
                                   FPU
                                   DMA controller
                                   PIC
                                   Keyboard controller
              /dev/lp0             Parallel controller
                                   PS/2 Controller
                                   Red Hat Virtio network device
              /dev/ttyS0           16550A
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_short(hwinfo),
            {
                "cpu": {0: "QEMU Virtual CPU version 2.5+, 3591 MHz"},
                "keyboard": {"/dev/input/event0": "AT Translated Set 2 keyboard"},
                "mouse": {"/dev/input/mice": "VirtualPS/2 VMware VMMouse"},
                "graphics card": {0: "VGA compatible controller"},
                "storage": {
                    0: "Floppy disk controller",
                    1: "Red Hat Qemu virtual machine",
                },
                "network": {"ens3": "Virtio Ethernet Card 0"},
                "network interface": {
                    "lo": "Loopback network interface",
                    "ens3": "Ethernet network interface",
                },
                "disk": {"/dev/fd0": "Disk", "/dev/sda": "QEMU HARDDISK"},
                "cdrom": {"/dev/sr0": "QEMU DVD-ROM"},
                "floppy": {"/dev/fd0": "Floppy Disk"},
                "bios": {0: "BIOS"},
                "bridge": {
                    0: "Red Hat Qemu virtual machine",
                    1: "Red Hat Qemu virtual machine",
                    2: "Red Hat Qemu virtual machine",
                },
                "memory": {0: "Main Memory"},
                "unknown": {
                    0: "FPU",
                    1: "DMA controller",
                    2: "PIC",
                    3: "Keyboard controller",
                    "/dev/lp0": "Parallel controller",
                    4: "PS/2 Controller",
                    5: "Red Hat Virtio network device",
                    "/dev/ttyS0": "16550A",
                },
            },
        )

def test__hwinfo_parse_full_floppy(self):
        hwinfo = textwrap.dedent(
            """
            01: None 00.0: 0102 Floppy disk controller
              [Created at floppy.112]
              Unique ID: rdCR.3wRL2_g4d2B
              Hardware Class: storage
              Model: "Floppy disk controller"
              I/O Port: 0x3f2 (rw)
              I/O Ports: 0x3f4-0x3f5 (rw)
              I/O Port: 0x3f7 (rw)
              DMA: 2
              Config Status: cfg=new, avail=yes, need=no, active=unknown

02: Floppy 00.0: 10603 Floppy Disk
              [Created at floppy.127]
              Unique ID: sPPV.oZ89vuho4Y3
              Parent ID: rdCR.3wRL2_g4d2B
              Hardware Class: floppy
              Model: "Floppy Disk"
              Device File: /dev/fd0
              Size: 3.5 ''
              Config Status: cfg=new, avail=yes, need=no, active=unknown
              Size: 5760 sectors a 512 bytes
              Capacity: 0 GB (2949120 bytes)
              Drive status: no medium
              Config Status: cfg=new, avail=yes, need=no, active=unknown
              Attached to: #1 (Floppy disk controller)
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "01": {
                    "None 00.0": "0102 Floppy disk controller",
                    "Note": "Created at floppy.112",
                    "Unique ID": "rdCR.3wRL2_g4d2B",
                    "Hardware Class": "storage",
                    "Model": "Floppy disk controller",
                    "I/O Ports": ["0x3f2 (rw)", "0x3f4-0x3f5 (rw)", "0x3f7 (rw)"],
                    "DMA": "2",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "02": {
                    "Floppy 00.0": "10603 Floppy Disk",
                    "Note": "Created at floppy.127",
                    "Unique ID": "sPPV.oZ89vuho4Y3",
                    "Parent ID": "rdCR.3wRL2_g4d2B",
                    "Hardware Class": "floppy",
                    "Model": "Floppy Disk",
                    "Device File": "/dev/fd0",
                    "Size": ["3.5 ''", "5760 sectors a 512 bytes"],
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                    "Capacity": "0 GB (2949120 bytes)",
                    "Drive status": "no medium",
                    "Attached to": {"Handle": "#1 (Floppy disk controller)"},
                },
            },
        )

def test__hwinfo_parse_full_bios(self):
        hwinfo = textwrap.dedent(
            """
            03: None 00.0: 10105 BIOS
              [Created at bios.186]
              Unique ID: rdCR.lZF+r4EgHp4
              Hardware Class: bios
              BIOS Keyboard LED Status:
                Scroll Lock: off
                Num Lock: off
                Caps Lock: off
              Serial Port 0: 0x3f8
              Parallel Port 0: 0x378
              Base Memory: 639 kB
              PnP BIOS: @@@0000
              MP spec rev 1.4 info:
                OEM id: "BOCHSCPU"
                Product id: "0.1"
                1 CPUs (0 disabled)
              BIOS32 Service Directory Entry: 0xfd2b0
              SMBIOS Version: 2.8
              BIOS Info: #0
                Vendor: "SeaBIOS"
                Version: "rel-1.12.1-0-ga5cab58e9a3f-prebuilt.qemu.org"
                Date: "04/01/2014"
                Start Address: 0xe8000
                ROM Size: 64 kB
                Features: 0x04000000000000000008
              System Info: #256
                Manufacturer: "QEMU"
                Product: "Standard PC (i440FX + PIIX, 1996)"
                Version: "pc-i440fx-4.0"
                UUID: undefined
                Wake-up: 0x06 (Power Switch)
              Chassis Info: #768
                Manufacturer: "QEMU"
                Version: "pc-i440fx-4.0"
                Type: 0x01 (Other)
                Bootup State: 0x03 (Safe)
                Power Supply State: 0x03 (Safe)
                Thermal State: 0x03 (Safe)
                Security Status: 0x02 (Unknown)
              Processor Info: #1024
                Socket: "CPU 0"
                Socket Type: 0x01 (Other)
                Socket Status: Populated
                Type: 0x03 (CPU)
                Family: 0x01 (Other)
                Manufacturer: "QEMU"
                Version: "pc-i440fx-4.0"
                Processor ID: 0x078bfbfd00000663
                Status: 0x01 (Enabled)
                Max. Speed: 2000 MHz
                Current Speed: 2000 MHz
              Physical Memory Array: #4096
                Use: 0x03 (System memory)
                Location: 0x01 (Other)
                Slots: 1
                Max. Size: 1 GB
                ECC: 0x06 (Multi-bit)
              Memory Device: #4352
                Location: "DIMM 0"
                Manufacturer: "QEMU"
                Memory Array: #4096
                Form Factor: 0x09 (DIMM)
                Type: 0x07 (RAM)
                Type Detail: 0x0002 (Other)
                Data Width: 0 bits
                 Size: 1 GB
              Memory Array Mapping: #4864
                Memory Array: #4096
                Partition Width: 1
                Start Address: 0x00000000
                End Address: 0x40000000
              Type 32 Record: #8192
                Data 00: 20 0b 00 20 00 00 00 00 00 00 00
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "03": {
                    "None 00.0": "10105 BIOS",
                    "Note": "Created at bios.186",
                    "Unique ID": "rdCR.lZF+r4EgHp4",
                    "Hardware Class": "bios",
                    "BIOS Keyboard LED Status": {
                        "Scroll Lock": "off",
                        "Num Lock": "off",
                        "Caps Lock": "off",
                    },
                    "Serial Port 0": "0x3f8",
                    "Parallel Port 0": "0x378",
                    "Base Memory": "639 kB",
                    "PnP BIOS": "@@@0000",
                    "MP spec rev 1.4 info": {
                        "OEM id": "BOCHSCPU",
                        "Product id": "0.1",
                        "Note": "1 CPUs (0 disabled)",
                    },
                    "BIOS32 Service Directory Entry": "0xfd2b0",
                    "SMBIOS Version": "2.8",
                    "BIOS Info": {
                        "Handle": "#0",
                        "Vendor": "SeaBIOS",
                        "Version": "rel-1.12.1-0-ga5cab58e9a3f-prebuilt.qemu.org",
                        "Date": "04/01/2014",
                        "Start Address": "0xe8000",
                        "ROM Size": "64 kB",
                        "Features": ["0x04000000000000000008"],
                    },
                    "System Info": {
                        "Handle": "#256",
                        "Manufacturer": "QEMU",
                        "Product": "Standard PC (i440FX + PIIX, 1996)",
                        "Version": "pc-i440fx-4.0",
                        "UUID": "undefined",
                        "Wake-up": "0x06 (Power Switch)",
                    },
                    "Chassis Info": {
                        "Handle": "#768",
                        "Manufacturer": "QEMU",
                        "Version": "pc-i440fx-4.0",
                        "Type": "0x01 (Other)",
                        "Bootup State": "0x03 (Safe)",
                        "Power Supply State": "0x03 (Safe)",
                        "Thermal State": "0x03 (Safe)",
                        "Security Status": "0x02 (Unknown)",
                    },
                    "Processor Info": {
                        "Handle": "#1024",
                        "Socket": "CPU 0",
                        "Socket Type": "0x01 (Other)",
                        "Socket Status": "Populated",
                        "Type": "0x03 (CPU)",
                        "Family": "0x01 (Other)",
                        "Manufacturer": "QEMU",
                        "Version": "pc-i440fx-4.0",
                        "Processor ID": "0x078bfbfd00000663",
                        "Status": "0x01 (Enabled)",
                        "Max. Speed": "2000 MHz",
                        "Current Speed": "2000 MHz",
                    },
                    "Physical Memory Array": {
                        "Handle": "#4096",
                        "Use": "0x03 (System memory)",
                        "Location": "0x01 (Other)",
                        "Slots": "1",
                        "Max. Size": "1 GB",
                        "ECC": "0x06 (Multi-bit)",
                    },
                    "Memory Device": {
                        "Handle": "#4352",
                        "Location": "DIMM 0",
                        "Manufacturer": "QEMU",
                        "Memory Array": {"Handle": "#4096"},
                        "Form Factor": "0x09 (DIMM)",
                        "Type": "0x07 (RAM)",
                        "Type Detail": "0x0002 (Other)",
                        "Data Width": "0 bits",
                        "Size": "1 GB",
                    },
                    "Memory Array Mapping": {
                        "Handle": "#4864",
                        "Memory Array": {"Handle": "#4096"},
                        "Partition Width": "1",
                        "Start Address": "0x00000000",
                        "End Address": "0x40000000",
                    },
                    "Type 32 Record": {
                        "Handle": "#8192",
                        "Data 00": "20 0b 00 20 00 00 00 00 00 00 00",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_system(self):
        hwinfo = textwrap.dedent(
            """
            04: None 00.0: 10107 System
              [Created at sys.64]
              Unique ID: rdCR.n_7QNeEnh23
              Hardware Class: system
              Model: "System"
              Formfactor: "desktop"
              Driver Info #0:
                Driver Status: thermal,fan are not active
                Driver Activation Cmd: "modprobe thermal; modprobe fan"
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "04": {
                    "None 00.0": "10107 System",
                    "Note": "Created at sys.64",
                    "Unique ID": "rdCR.n_7QNeEnh23",
                    "Hardware Class": "system",
                    "Model": "System",
                    "Formfactor": "desktop",
                    "Driver Info #0": {
                        "Driver Status": "thermal,fan are not active",
                        "Driver Activation Cmd": "modprobe thermal; modprobe fan",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_unknown(self):
        hwinfo = textwrap.dedent(
            """
            05: None 00.0: 10104 FPU
              [Created at misc.191]
              Unique ID: rdCR.EMpH5pjcahD
              Hardware Class: unknown
              Model: "FPU"
              I/O Ports: 0xf0-0xff (rw)
              Config Status: cfg=new, avail=yes, need=no, active=unknown

06: None 00.0: 0801 DMA controller (8237)
              [Created at misc.205]
              Unique ID: rdCR.f5u1ucRm+H9
              Hardware Class: unknown
              Model: "DMA controller"
              I/O Ports: 0x00-0xcf7 (rw)
              I/O Ports: 0xc0-0xdf (rw)
              I/O Ports: 0x80-0x8f (rw)
              DMA: 4
              Config Status: cfg=new, avail=yes, need=no, active=unknown

07: None 00.0: 0800 PIC (8259)
              [Created at misc.218]
              Unique ID: rdCR.8uRK7LxiIA2
              Hardware Class: unknown
              Model: "PIC"
              I/O Ports: 0x20-0x21 (rw)
              I/O Ports: 0xa0-0xa1 (rw)
              Config Status: cfg=new, avail=yes, need=no, active=unknown

08: None 00.0: 0900 Keyboard controller
              [Created at misc.250]
              Unique ID: rdCR.9N+EecqykME
              Hardware Class: unknown
              Model: "Keyboard controller"
              I/O Port: 0x60 (rw)
              I/O Port: 0x64 (rw)
              Config Status: cfg=new, avail=yes, need=no, active=unknown

09: None 00.0: 0701 Parallel controller (SPP)
              [Created at misc.261]
              Unique ID: YMnp.ecK7NLYWZ5D
              Hardware Class: unknown
              Model: "Parallel controller"
              Device File: /dev/lp0
              I/O Ports: 0x378-0x37a (rw)
              I/O Ports: 0x37b-0x37f (rw)
              Config Status: cfg=new, avail=yes, need=no, active=unknown

10: None 00.0: 10400 PS/2 Controller
              [Created at misc.303]
              Unique ID: rdCR.DziBbWO85o5
              Hardware Class: unknown
              Model: "PS/2 Controller"
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "05": {
                    "None 00.0": "10104 FPU",
                    "Note": "Created at misc.191",
                    "Unique ID": "rdCR.EMpH5pjcahD",
                    "Hardware Class": "unknown",
                    "Model": "FPU",
                    "I/O Ports": "0xf0-0xff (rw)",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "06": {
                    "None 00.0": "0801 DMA controller (8237)",
                    "Note": "Created at misc.205",
                    "Unique ID": "rdCR.f5u1ucRm+H9",
                    "Hardware Class": "unknown",
                    "Model": "DMA controller",
                    "I/O Ports": [
                        "0x00-0xcf7 (rw)",
                        "0xc0-0xdf (rw)",
                        "0x80-0x8f (rw)",
                    ],
                    "DMA": "4",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "07": {
                    "None 00.0": "0800 PIC (8259)",
                    "Note": "Created at misc.218",
                    "Unique ID": "rdCR.8uRK7LxiIA2",
                    "Hardware Class": "unknown",
                    "Model": "PIC",
                    "I/O Ports": ["0x20-0x21 (rw)", "0xa0-0xa1 (rw)"],
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "08": {
                    "None 00.0": "0900 Keyboard controller",
                    "Note": "Created at misc.250",
                    "Unique ID": "rdCR.9N+EecqykME",
                    "Hardware Class": "unknown",
                    "Model": "Keyboard controller",
                    "I/O Ports": ["0x60 (rw)", "0x64 (rw)"],
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "09": {
                    "None 00.0": "0701 Parallel controller (SPP)",
                    "Note": "Created at misc.261",
                    "Unique ID": "YMnp.ecK7NLYWZ5D",
                    "Hardware Class": "unknown",
                    "Model": "Parallel controller",
                    "Device File": "/dev/lp0",
                    "I/O Ports": ["0x378-0x37a (rw)", "0x37b-0x37f (rw)"],
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "10": {
                    "None 00.0": "10400 PS/2 Controller",
                    "Note": "Created at misc.303",
                    "Unique ID": "rdCR.DziBbWO85o5",
                    "Hardware Class": "unknown",
                    "Model": "PS/2 Controller",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_memory(self):
        hwinfo = textwrap.dedent(
            """
            12: None 00.0: 10102 Main Memory
              [Created at memory.74]
              Unique ID: rdCR.CxwsZFjVASF
              Hardware Class: memory
              Model: "Main Memory"
              Memory Range: 0x00000000-0x3cefffff (rw)
              Memory Size: 960 MB
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "12": {
                    "None 00.0": "10102 Main Memory",
                    "Note": "Created at memory.74",
                    "Unique ID": "rdCR.CxwsZFjVASF",
                    "Hardware Class": "memory",
                    "Model": "Main Memory",
                    "Memory Range": "0x00000000-0x3cefffff (rw)",
                    "Memory Size": "960 MB",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_bridge(self):
        hwinfo = textwrap.dedent(
            """
            13: PCI 01.0: 0601 ISA bridge
              [Created at pci.386]
              Unique ID: vSkL.ucdhKwLeeAA
              SysFS ID: /devices/pci0000:00/0000:00:01.0
              SysFS BusID: 0000:00:01.0
              Hardware Class: bridge
              Model: "Red Hat Qemu virtual machine"
              Vendor: pci 0x8086 "Intel Corporation"
              Device: pci 0x7000 "82371SB PIIX3 ISA [Natoma/Triton II]"
              SubVendor: pci 0x1af4 "Red Hat, Inc."
              SubDevice: pci 0x1100 "Qemu virtual machine"
              Module Alias: "pci:v00008086d00007000sv00001AF4sd00001100bc06sc01i00"
              Config Status: cfg=new, avail=yes, need=no, active=unknown

14: PCI 00.0: 0600 Host bridge
              [Created at pci.386]
              Unique ID: qLht.YeL3TKDjrxE
              SysFS ID: /devices/pci0000:00/0000:00:00.0
              SysFS BusID: 0000:00:00.0
              Hardware Class: bridge
              Model: "Red Hat Qemu virtual machine"
              Vendor: pci 0x8086 "Intel Corporation"
              Device: pci 0x1237 "440FX - 82441FX PMC [Natoma]"
              SubVendor: pci 0x1af4 "Red Hat, Inc."
              SubDevice: pci 0x1100 "Qemu virtual machine"
              Revision: 0x02
              Module Alias: "pci:v00008086d00001237sv00001AF4sd00001100bc06sc00i00"
              Config Status: cfg=new, avail=yes, need=no, active=unknown

15: PCI 01.3: 0680 Bridge
              [Created at pci.386]
              Unique ID: VRCs.M9Cc8lcQjE2
              SysFS ID: /devices/pci0000:00/0000:00:01.3
              SysFS BusID: 0000:00:01.3
              Hardware Class: bridge
              Model: "Red Hat Qemu virtual machine"
              Vendor: pci 0x8086 "Intel Corporation"
              Device: pci 0x7113 "82371AB/EB/MB PIIX4 ACPI"
              SubVendor: pci 0x1af4 "Red Hat, Inc."
              SubDevice: pci 0x1100 "Qemu virtual machine"
              Revision: 0x03
              Driver: "piix4_smbus"
              Driver Modules: "i2c_piix4"
              IRQ: 9 (no events)
              Module Alias: "pci:v00008086d00007113sv00001AF4sd00001100bc06sc80i00"
              Driver Info #0:
                Driver Status: i2c_piix4 is active
                Driver Activation Cmd: "modprobe i2c_piix4"
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "13": {
                    "PCI 01.0": "0601 ISA bridge",
                    "Note": "Created at pci.386",
                    "Unique ID": "vSkL.ucdhKwLeeAA",
                    "SysFS ID": "/devices/pci0000:00/0000:00:01.0",
                    "SysFS BusID": "0000:00:01.0",
                    "Hardware Class": "bridge",
                    "Model": "Red Hat Qemu virtual machine",
                    "Vendor": 'pci 0x8086 "Intel Corporation"',
                    "Device": 'pci 0x7000 "82371SB PIIX3 ISA [Natoma/Triton II]"',
                    "SubVendor": 'pci 0x1af4 "Red Hat, Inc."',
                    "SubDevice": 'pci 0x1100 "Qemu virtual machine"',
                    "Module Alias": "pci:v00008086d00007000sv00001AF4sd00001100bc06sc01i00",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "14": {
                    "PCI 00.0": "0600 Host bridge",
                    "Note": "Created at pci.386",
                    "Unique ID": "qLht.YeL3TKDjrxE",
                    "SysFS ID": "/devices/pci0000:00/0000:00:00.0",
                    "SysFS BusID": "0000:00:00.0",
                    "Hardware Class": "bridge",
                    "Model": "Red Hat Qemu virtual machine",
                    "Vendor": 'pci 0x8086 "Intel Corporation"',
                    "Device": 'pci 0x1237 "440FX - 82441FX PMC [Natoma]"',
                    "SubVendor": 'pci 0x1af4 "Red Hat, Inc."',
                    "SubDevice": 'pci 0x1100 "Qemu virtual machine"',
                    "Revision": "0x02",
                    "Module Alias": "pci:v00008086d00001237sv00001AF4sd00001100bc06sc00i00",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "15": {
                    "PCI 01.3": "0680 Bridge",
                    "Note": "Created at pci.386",
                    "Unique ID": "VRCs.M9Cc8lcQjE2",
                    "SysFS ID": "/devices/pci0000:00/0000:00:01.3",
                    "SysFS BusID": "0000:00:01.3",
                    "Hardware Class": "bridge",
                    "Model": "Red Hat Qemu virtual machine",
                    "Vendor": 'pci 0x8086 "Intel Corporation"',
                    "Device": 'pci 0x7113 "82371AB/EB/MB PIIX4 ACPI"',
                    "SubVendor": 'pci 0x1af4 "Red Hat, Inc."',
                    "SubDevice": 'pci 0x1100 "Qemu virtual machine"',
                    "Revision": "0x03",
                    "Driver": ["piix4_smbus"],
                    "Driver Modules": ["i2c_piix4"],
                    "IRQ": "9 (no events)",
                    "Module Alias": "pci:v00008086d00007113sv00001AF4sd00001100bc06sc80i00",
                    "Driver Info #0": {
                        "Driver Status": "i2c_piix4 is active",
                        "Driver Activation Cmd": "modprobe i2c_piix4",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_ethernet(self):
        hwinfo = textwrap.dedent(
            """
            16: PCI 03.0: 0200 Ethernet controller
              [Created at pci.386]
              Unique ID: 3hqH.pkM7KXDR457
              SysFS ID: /devices/pci0000:00/0000:00:03.0
              SysFS BusID: 0000:00:03.0
              Hardware Class: unknown
              Model: "Red Hat Virtio network device"
              Vendor: pci 0x1af4 "Red Hat, Inc."
              Device: pci 0x1000 "Virtio network device"
              SubVendor: pci 0x1af4 "Red Hat, Inc."
              SubDevice: pci 0x0001 
              Driver: "virtio-pci"
              Driver Modules: "virtio_pci"
              I/O Ports: 0xc000-0xc01f (rw)
              Memory Range: 0xfebd1000-0xfebd1fff (rw,non-prefetchable)
              Memory Range: 0xfe000000-0xfe003fff (ro,non-prefetchable)
              Memory Range: 0xfeb80000-0xfebbffff (ro,non-prefetchable,disabled)
              IRQ: 11 (no events)
              Module Alias: "pci:v00001AF4d00001000sv00001AF4sd00000001bc02sc00i00"
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "16": {
                    "PCI 03.0": "0200 Ethernet controller",
                    "Note": "Created at pci.386",
                    "Unique ID": "3hqH.pkM7KXDR457",
                    "SysFS ID": "/devices/pci0000:00/0000:00:03.0",
                    "SysFS BusID": "0000:00:03.0",
                    "Hardware Class": "unknown",
                    "Model": "Red Hat Virtio network device",
                    "Vendor": 'pci 0x1af4 "Red Hat, Inc."',
                    "Device": 'pci 0x1000 "Virtio network device"',
                    "SubVendor": 'pci 0x1af4 "Red Hat, Inc."',
                    "SubDevice": "pci 0x0001",
                    "Driver": ["virtio-pci"],
                    "Driver Modules": ["virtio_pci"],
                    "I/O Ports": "0xc000-0xc01f (rw)",
                    "Memory Range": [
                        "0xfebd1000-0xfebd1fff (rw,non-prefetchable)",
                        "0xfe000000-0xfe003fff (ro,non-prefetchable)",
                        "0xfeb80000-0xfebbffff (ro,non-prefetchable,disabled)",
                    ],
                    "IRQ": "11 (no events)",
                    "Module Alias": "pci:v00001AF4d00001000sv00001AF4sd00000001bc02sc00i00",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_storage(self):
        hwinfo = textwrap.dedent(
            """
            17: PCI 01.1: 0101 IDE interface (ISA Compatibility mode-only controller, supports bus mts bus mastering)
              [Created at pci.386]
              Unique ID: mnDB.3sKqaxiizg6
              SysFS ID: /devices/pci0000:00/0000:00:01.1
              SysFS BusID: 0000:00:01.1
              Hardware Class: storage
              Model: "Red Hat Qemu virtual machine"
              Vendor: pci 0x8086 "Intel Corporation"
              Device: pci 0x7010 "82371SB PIIX3 IDE [Natoma/Triton II]"
              SubVendor: pci 0x1af4 "Red Hat, Inc."
              SubDevice: pci 0x1100 "Qemu virtual machine"
              Driver: "ata_piix"
              Driver Modules: "ata_piix"
              I/O Ports: 0x1f0-0x1f7 (rw)
              I/O Port: 0x3f6 (rw)
              I/O Ports: 0x170-0x177 (rw)
              I/O Port: 0x376 (rw)
              I/O Ports: 0xc020-0xc02f (rw)
              Module Alias: "pci:v00008086d00007010sv00001AF4sd00001100bc01sc01i80"
              Driver Info #0:
                Driver Status: ata_piix is active
                Driver Activation Cmd: "modprobe ata_piix"
              Driver Info #1:
                Driver Status: ata_generic is active
                Driver Activation Cmd: "modprobe ata_generic"
              Driver Info #2:
                Driver Status: pata_acpi is active
                Driver Activation Cmd: "modprobe pata_acpi"
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "17": {
                    "PCI 01.1": "0101 IDE interface (ISA Compatibility mode-only controller, supports bus mts bus mastering)",
                    "Note": "Created at pci.386",
                    "Unique ID": "mnDB.3sKqaxiizg6",
                    "SysFS ID": "/devices/pci0000:00/0000:00:01.1",
                    "SysFS BusID": "0000:00:01.1",
                    "Hardware Class": "storage",
                    "Model": "Red Hat Qemu virtual machine",
                    "Vendor": 'pci 0x8086 "Intel Corporation"',
                    "Device": 'pci 0x7010 "82371SB PIIX3 IDE [Natoma/Triton II]"',
                    "SubVendor": 'pci 0x1af4 "Red Hat, Inc."',
                    "SubDevice": 'pci 0x1100 "Qemu virtual machine"',
                    "Driver": ["ata_piix"],
                    "Driver Modules": ["ata_piix"],
                    "I/O Ports": [
                        "0x1f0-0x1f7 (rw)",
                        "0x3f6 (rw)",
                        "0x170-0x177 (rw)",
                        "0x376 (rw)",
                        "0xc020-0xc02f (rw)",
                    ],
                    "Module Alias": "pci:v00008086d00007010sv00001AF4sd00001100bc01sc01i80",
                    "Driver Info #0": {
                        "Driver Status": "ata_piix is active",
                        "Driver Activation Cmd": "modprobe ata_piix",
                    },
                    "Driver Info #1": {
                        "Driver Status": "ata_generic is active",
                        "Driver Activation Cmd": "modprobe ata_generic",
                    },
                    "Driver Info #2": {
                        "Driver Status": "pata_acpi is active",
                        "Driver Activation Cmd": "modprobe pata_acpi",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_video(self):
        hwinfo = textwrap.dedent(
            """
            18: PCI 02.0: 0300 VGA compatible controller (VGA)
              [Created at pci.386]
              Unique ID: _Znp.WspiKb87LiA
              SysFS ID: /devices/pci0000:00/0000:00:02.0
              SysFS BusID: 0000:00:02.0
              Hardware Class: graphics card
              Model: "VGA compatible controller"
              Vendor: pci 0x1234
              Device: pci 0x1111
              SubVendor: pci 0x1af4 "Red Hat, Inc."
              SubDevice: pci 0x1100
              Revision: 0x02
              Driver: "bochs-drm"
              Driver Modules: "bochs_drm"
              Memory Range: 0xfd000000-0xfdffffff (ro,non-prefetchable)
              Memory Range: 0xfebd0000-0xfebd0fff (rw,non-prefetchable)
              Memory Range: 0x000c0000-0x000dffff (rw,non-prefetchable,disabled)
              Module Alias: "pci:v00001234d00001111sv00001AF4sd00001100bc03sc00i00"
              Driver Info #0:
                Driver Status: bochs_drm is active
                Driver Activation Cmd: "modprobe bochs_drm"
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "18": {
                    "PCI 02.0": "0300 VGA compatible controller (VGA)",
                    "Note": "Created at pci.386",
                    "Unique ID": "_Znp.WspiKb87LiA",
                    "SysFS ID": "/devices/pci0000:00/0000:00:02.0",
                    "SysFS BusID": "0000:00:02.0",
                    "Hardware Class": "graphics card",
                    "Model": "VGA compatible controller",
                    "Vendor": "pci 0x1234",
                    "Device": "pci 0x1111",
                    "SubVendor": 'pci 0x1af4 "Red Hat, Inc."',
                    "SubDevice": "pci 0x1100",
                    "Revision": "0x02",
                    "Driver": ["bochs-drm"],
                    "Driver Modules": ["bochs_drm"],
                    "Memory Range": [
                        "0xfd000000-0xfdffffff (ro,non-prefetchable)",
                        "0xfebd0000-0xfebd0fff (rw,non-prefetchable)",
                        "0x000c0000-0x000dffff (rw,non-prefetchable,disabled)",
                    ],
                    "Module Alias": "pci:v00001234d00001111sv00001AF4sd00001100bc03sc00i00",
                    "Driver Info #0": {
                        "Driver Status": "bochs_drm is active",
                        "Driver Activation Cmd": "modprobe bochs_drm",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_network(self):
        hwinfo = textwrap.dedent(
            """
            19: Virtio 00.0: 0200 Ethernet controller
              [Created at pci.1679]
              Unique ID: vWuh.VIRhsc57kTD
              Parent ID: 3hqH.pkM7KXDR457
              SysFS ID: /devices/pci0000:00/0000:00:03.0/virtio0
              SysFS BusID: virtio0
              Hardware Class: network
              Model: "Virtio Ethernet Card 0"
              Vendor: int 0x6014 "Virtio"
              Device: int 0x0001 "Ethernet Card 0"
              Driver: "virtio_net"
              Driver Modules: "virtio_net"
              Device File: ens3
              HW Address: 52:54:00:12:34:56
              Permanent HW Address: 52:54:00:12:34:56
              Link detected: yes
              Module Alias: "virtio:d00000001v00001AF4"
              Driver Info #0:
                Driver Status: virtio_net is active
                Driver Activation Cmd: "modprobe virtio_net"
              Config Status: cfg=new, avail=yes, need=no, active=unknown
              Attached to: #16 (Ethernet controller)

20: None 00.0: 0700 Serial controller (16550)
              [Created at serial.74]
              Unique ID: S_Uw.3fyvFV+mbWD
              Hardware Class: unknown
              Model: "16550A"
              Device: "16550A"
              Device File: /dev/ttyS0
              Tags: mouse, modem, braille
              I/O Ports: 0x3f8-0x3ff (rw)
              IRQ: 4 (55234 events)
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "19": {
                    "Virtio 00.0": "0200 Ethernet controller",
                    "Note": "Created at pci.1679",
                    "Unique ID": "vWuh.VIRhsc57kTD",
                    "Parent ID": "3hqH.pkM7KXDR457",
                    "SysFS ID": "/devices/pci0000:00/0000:00:03.0/virtio0",
                    "SysFS BusID": "virtio0",
                    "Hardware Class": "network",
                    "Model": "Virtio Ethernet Card 0",
                    "Vendor": 'int 0x6014 "Virtio"',
                    "Device": 'int 0x0001 "Ethernet Card 0"',
                    "Driver": ["virtio_net"],
                    "Driver Modules": ["virtio_net"],
                    "Device File": "ens3",
                    "HW Address": "52:54:00:12:34:56",
                    "Permanent HW Address": "52:54:00:12:34:56",
                    "Link detected": "yes",
                    "Module Alias": "virtio:d00000001v00001AF4",
                    "Driver Info #0": {
                        "Driver Status": "virtio_net is active",
                        "Driver Activation Cmd": "modprobe virtio_net",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                    "Attached to": {"Handle": "#16 (Ethernet controller)"},
                },
                "20": {
                    "None 00.0": "0700 Serial controller (16550)",
                    "Note": "Created at serial.74",
                    "Unique ID": "S_Uw.3fyvFV+mbWD",
                    "Hardware Class": "unknown",
                    "Model": "16550A",
                    "Device": "16550A",
                    "Device File": "/dev/ttyS0",
                    "Tags": ["mouse", "modem", "braille"],
                    "I/O Ports": "0x3f8-0x3ff (rw)",
                    "IRQ": "4 (55234 events)",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_disk(self):
        hwinfo = textwrap.dedent(
            """
            21: SCSI 100.0: 10602 CD-ROM (DVD)
              [Created at block.249]
              Unique ID: KD9E.53N0UD4ozwD
              Parent ID: mnDB.3sKqaxiizg6
              SysFS ID: /class/block/sr0
              SysFS BusID: 1:0:0:0
              SysFS Device Link: /devices/pci0000:00/0000:00:01.1/ata2/host1/target1:0:0/1:0:0:0
              Hardware Class: cdrom
              Model: "QEMU DVD-ROM"
              Vendor: "QEMU"
              Device: "QEMU DVD-ROM"
              Revision: "2.5+"
              Driver: "ata_piix", "sr"
              Driver Modules: "ata_piix", "sr_mod"
              Device File: /dev/sr0 (/dev/sg1)
              Device Files: /dev/sr0, /dev/cdrom, /dev/dvd, /dev/disk/by-path/pci-0000:00:01.1-ata-2, /dev/disk/by-id/ata-QEMU_DVD-ROM_QM00003, /dev/disk/by-uuid/2019-08-11-11-44-39-00, /dev/disk/by-label/CDROM
              Device Number: block 11:0 (char 21:1)
              Features: DVD, MRW, MRW-W
              Config Status: cfg=new, avail=yes, need=no, active=unknown
              Attached to: #17 (IDE interface)
              Drive Speed: 4
              Volume ID: "CDROM"
              Application: "0X5228779D"
              Publisher: "SUSE LLC"
              Preparer: "KIWI - HTTPS://GITHUB.COM/OSINSIDE/KIWI"
              Creation date: "2019081111443900"
              El Torito info: platform 0, bootable
                Boot Catalog: at sector 0x00fa
                Media: none starting at sector 0x00fb
                Load: 2048 bytes

22: None 00.0: 10600 Disk
              [Created at block.245]
              Unique ID: kwWm.Fxp0d3BezAE
              SysFS ID: /class/block/fd0
              SysFS BusID: floppy.0
              SysFS Device Link: /devices/platform/floppy.0
              Hardware Class: disk
              Model: "Disk"
              Driver: "floppy"
              Driver Modules: "floppy"
              Device File: /dev/fd0
              Device Number: block 2:0
              Size: 8 sectors a 512 bytes
              Capacity: 0 GB (4096 bytes)
              Drive status: no medium
              Config Status: cfg=new, avail=yes, need=no, active=unknown

23: IDE 00.0: 10600 Disk
              [Created at block.245]
              Unique ID: 3OOL.W8iGvCekDp8
              Parent ID: mnDB.3sKqaxiizg6
              SysFS ID: /class/block/sda
              SysFS BusID: 0:0:0:0
              SysFS Device Link: /devices/pci0000:00/0000:00:01.1/ata1/host0/target0:0:0/0:0:0:0
              Hardware Class: disk
              Model: "QEMU HARDDISK"
              Vendor: "QEMU"
              Device: "HARDDISK"
              Revision: "2.5+"
              Serial ID: "QM00001"
              Driver: "ata_piix", "sd"
              Driver Modules: "ata_piix"
              Device File: /dev/sda
              Device Files: /dev/sda, /dev/disk/by-path/pci-0000:00:01.1-ata-1, /dev/disk/by-id/ata-QEMU_HARDDISK_QM00001
              Device Number: block 8:0-8:15
              Geometry (Logical): CHS 3133/255/63
              Size: 50331648 sectors a 512 bytes
              Capacity: 24 GB (25769803776 bytes)
              Config Status: cfg=new, avail=yes, need=no, active=unknown
              Attached to: #17 (IDE interface)
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "21": {
                    "SCSI 100.0": "10602 CD-ROM (DVD)",
                    "Note": "Created at block.249",
                    "Unique ID": "KD9E.53N0UD4ozwD",
                    "Parent ID": "mnDB.3sKqaxiizg6",
                    "SysFS ID": "/class/block/sr0",
                    "SysFS BusID": "1:0:0:0",
                    "SysFS Device Link": "/devices/pci0000:00/0000:00:01.1/ata2/host1/target1:0:0/1:0:0:0",
                    "Hardware Class": "cdrom",
                    "Model": "QEMU DVD-ROM",
                    "Vendor": "QEMU",
                    "Device": "QEMU DVD-ROM",
                    "Revision": "2.5+",
                    "Driver": ["ata_piix", "sr"],
                    "Driver Modules": ["ata_piix", "sr_mod"],
                    "Device File": "/dev/sr0 (/dev/sg1)",
                    "Device Files": [
                        "/dev/sr0",
                        "/dev/cdrom",
                        "/dev/dvd",
                        "/dev/disk/by-path/pci-0000:00:01.1-ata-2",
                        "/dev/disk/by-id/ata-QEMU_DVD-ROM_QM00003",
                        "/dev/disk/by-uuid/2019-08-11-11-44-39-00",
                        "/dev/disk/by-label/CDROM",
                    ],
                    "Device Number": "block 11:0 (char 21:1)",
                    "Features": ["DVD", "MRW", "MRW-W"],
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                    "Attached to": {"Handle": "#17 (IDE interface)"},
                    "Drive Speed": "4",
                    "Volume ID": "CDROM",
                    "Application": "0X5228779D",
                    "Publisher": "SUSE LLC",
                    "Preparer": "KIWI - HTTPS://GITHUB.COM/OSINSIDE/KIWI",
                    "Creation date": "2019081111443900",
                    "El Torito info": {
                        "platform": "0",
                        "bootable": "yes",
                        "Boot Catalog": "at sector 0x00fa",
                        "Media": "none starting at sector 0x00fb",
                        "Load": "2048 bytes",
                    },
                },
                "22": {
                    "None 00.0": "10600 Disk",
                    "Note": "Created at block.245",
                    "Unique ID": "kwWm.Fxp0d3BezAE",
                    "SysFS ID": "/class/block/fd0",
                    "SysFS BusID": "floppy.0",
                    "SysFS Device Link": "/devices/platform/floppy.0",
                    "Hardware Class": "disk",
                    "Model": "Disk",
                    "Driver": ["floppy"],
                    "Driver Modules": ["floppy"],
                    "Device File": "/dev/fd0",
                    "Device Number": "block 2:0",
                    "Size": "8 sectors a 512 bytes",
                    "Capacity": "0 GB (4096 bytes)",
                    "Drive status": "no medium",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "23": {
                    "IDE 00.0": "10600 Disk",
                    "Note": "Created at block.245",
                    "Unique ID": "3OOL.W8iGvCekDp8",
                    "Parent ID": "mnDB.3sKqaxiizg6",
                    "SysFS ID": "/class/block/sda",
                    "SysFS BusID": "0:0:0:0",
                    "SysFS Device Link": "/devices/pci0000:00/0000:00:01.1/ata1/host0/target0:0:0/0:0:0:0",
                    "Hardware Class": "disk",
                    "Model": "QEMU HARDDISK",
                    "Vendor": "QEMU",
                    "Device": "HARDDISK",
                    "Revision": "2.5+",
                    "Serial ID": "QM00001",
                    "Driver": ["ata_piix", "sd"],
                    "Driver Modules": ["ata_piix"],
                    "Device File": "/dev/sda",
                    "Device Files": [
                        "/dev/sda",
                        "/dev/disk/by-path/pci-0000:00:01.1-ata-1",
                        "/dev/disk/by-id/ata-QEMU_HARDDISK_QM00001",
                    ],
                    "Device Number": "block 8:0-8:15",
                    "Geometry (Logical)": "CHS 3133/255/63",
                    "Size": "50331648 sectors a 512 bytes",
                    "Capacity": "24 GB (25769803776 bytes)",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                    "Attached to": {"Handle": "#17 (IDE interface)"},
                },
            },
        )

def test__hwinfo_parse_full_keyboard(self):
        hwinfo = textwrap.dedent(
            """
            24: PS/2 00.0: 10800 Keyboard
              [Created at input.226]
              Unique ID: nLyy.+49ps10DtUF
              Hardware Class: keyboard
              Model: "AT Translated Set 2 keyboard"
              Vendor: 0x0001
              Device: 0x0001 "AT Translated Set 2 keyboard"
              Compatible to: int 0x0211 0x0001
              Device File: /dev/input/event0
              Device Files: /dev/input/event0, /dev/input/by-path/platform-i8042-serio-0-event-kbd
              Device Number: char 13:64
              Driver Info #0:
                XkbRules: xfree86
                XkbModel: pc104
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "24": {
                    "PS/2 00.0": "10800 Keyboard",
                    "Note": "Created at input.226",
                    "Unique ID": "nLyy.+49ps10DtUF",
                    "Hardware Class": "keyboard",
                    "Model": "AT Translated Set 2 keyboard",
                    "Vendor": "0x0001",
                    "Device": '0x0001 "AT Translated Set 2 keyboard"',
                    "Compatible to": "int 0x0211 0x0001",
                    "Device File": "/dev/input/event0",
                    "Device Files": [
                        "/dev/input/event0",
                        "/dev/input/by-path/platform-i8042-serio-0-event-kbd",
                    ],
                    "Device Number": "char 13:64",
                    "Driver Info #0": {"XkbRules": "xfree86", "XkbModel": "pc104"},
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_mouse(self):
        hwinfo = textwrap.dedent(
            """
            25: PS/2 00.0: 10500 PS/2 Mouse
              [Created at input.249]
              Unique ID: AH6Q.mYF0pYoTCW7
              Hardware Class: mouse
              Model: "VirtualPS/2 VMware VMMouse"
              Vendor: 0x0002
              Device: 0x0013 "VirtualPS/2 VMware VMMouse"
              Compatible to: int 0x0210 0x0003
              Device File: /dev/input/mice (/dev/input/mouse0)
              Device Files: /dev/input/mice, /dev/input/mouse0, /dev/input/event1, /dev/input/by-path/platform-i8042-serio-1-event-mouse, /dev/input/by-path/platform-i8042-serio-1-mouse
              Device Number: char 13:63 (char 13:32)
              Driver Info #0:
                Buttons: 3
                Wheels: 0
                XFree86 Protocol: explorerps/2
                GPM Protocol: exps2
              Config Status: cfg=new, avail=yes, need=no, active=unknown

26: PS/2 00.0: 10500 PS/2 Mouse
              [Created at input.249]
              Unique ID: AH6Q.++hSeDccb2F
              Hardware Class: mouse
              Model: "VirtualPS/2 VMware VMMouse"
              Vendor: 0x0002
              Device: 0x0013 "VirtualPS/2 VMware VMMouse"
              Compatible to: int 0x0210 0x0012
              Device File: /dev/input/mice (/dev/input/mouse1)
              Device Files: /dev/input/mice, /dev/input/mouse1, /dev/input/event2
              Device Number: char 13:63 (char 13:33)
              Driver Info #0:
                Buttons: 2
                Wheels: 1
                XFree86 Protocol: explorerps/2
                GPM Protocol: exps2
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "25": {
                    "PS/2 00.0": "10500 PS/2 Mouse",
                    "Note": "Created at input.249",
                    "Unique ID": "AH6Q.mYF0pYoTCW7",
                    "Hardware Class": "mouse",
                    "Model": "VirtualPS/2 VMware VMMouse",
                    "Vendor": "0x0002",
                    "Device": '0x0013 "VirtualPS/2 VMware VMMouse"',
                    "Compatible to": "int 0x0210 0x0003",
                    "Device File": "/dev/input/mice (/dev/input/mouse0)",
                    "Device Files": [
                        "/dev/input/mice",
                        "/dev/input/mouse0",
                        "/dev/input/event1",
                        "/dev/input/by-path/platform-i8042-serio-1-event-mouse",
                        "/dev/input/by-path/platform-i8042-serio-1-mouse",
                    ],
                    "Device Number": "char 13:63 (char 13:32)",
                    "Driver Info #0": {
                        "Buttons": "3",
                        "Wheels": "0",
                        "XFree86 Protocol": "explorerps/2",
                        "GPM Protocol": "exps2",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "26": {
                    "PS/2 00.0": "10500 PS/2 Mouse",
                    "Note": "Created at input.249",
                    "Unique ID": "AH6Q.++hSeDccb2F",
                    "Hardware Class": "mouse",
                    "Model": "VirtualPS/2 VMware VMMouse",
                    "Vendor": "0x0002",
                    "Device": '0x0013 "VirtualPS/2 VMware VMMouse"',
                    "Compatible to": "int 0x0210 0x0012",
                    "Device File": "/dev/input/mice (/dev/input/mouse1)",
                    "Device Files": [
                        "/dev/input/mice",
                        "/dev/input/mouse1",
                        "/dev/input/event2",
                    ],
                    "Device Number": "char 13:63 (char 13:33)",
                    "Driver Info #0": {
                        "Buttons": "2",
                        "Wheels": "1",
                        "XFree86 Protocol": "explorerps/2",
                        "GPM Protocol": "exps2",
                    },
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_cpu(self):
        hwinfo = textwrap.dedent(
            """
            27: None 00.0: 10103 CPU
              [Created at cpu.462]
              Unique ID: rdCR.j8NaKXDZtZ6
              Hardware Class: cpu
              Arch: X86-64
              Vendor: "GenuineIntel"
              Model: 6.6.3 "QEMU Virtual CPU version 2.5+"
              Features: fpu,de,pse,tsc,msr,pae,mce,cx8,apic,sep,mtrr,pge,mca,cmov,pse36,clflush,mmx,fxsr,sse,sse2,syscall,nx,lm,rep_good,nopl,xtopology,cpuid,tsc_known_freq,pni,cx16,x2apic,hypervisor,lahf_lm,cpuid_fault,pti
              Clock: 3591 MHz
              BogoMips: 7182.68
              Cache: 16384 kb
              Config Status: cfg=new, avail=yes, need=no, active=unknown
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "27": {
                    "None 00.0": "10103 CPU",
                    "Note": "Created at cpu.462",
                    "Unique ID": "rdCR.j8NaKXDZtZ6",
                    "Hardware Class": "cpu",
                    "Arch": "X86-64",
                    "Vendor": "GenuineIntel",
                    "Model": '6.6.3 "QEMU Virtual CPU version 2.5+"',
                    "Features": [
                        "fpu",
                        "de",
                        "pse",
                        "tsc",
                        "msr",
                        "pae",
                        "mce",
                        "cx8",
                        "apic",
                        "sep",
                        "mtrr",
                        "pge",
                        "mca",
                        "cmov",
                        "pse36",
                        "clflush",
                        "mmx",
                        "fxsr",
                        "sse",
                        "sse2",
                        "syscall",
                        "nx",
                        "lm",
                        "rep_good",
                        "nopl",
                        "xtopology",
                        "cpuid",
                        "tsc_known_freq",
                        "pni",
                        "cx16",
                        "x2apic",
                        "hypervisor",
                        "lahf_lm",
                        "cpuid_fault",
                        "pti",
                    ],
                    "Clock": "3591 MHz",
                    "BogoMips": "7182.68",
                    "Cache": "16384 kb",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
            },
        )

def test__hwinfo_parse_full_nic(self):
        hwinfo = textwrap.dedent(
            """
            28: None 00.0: 10700 Loopback
              [Created at net.126]
              Unique ID: ZsBS.GQNx7L4uPNA
              SysFS ID: /class/net/lo
              Hardware Class: network interface
              Model: "Loopback network interface"
              Device File: lo
              Link detected: yes
              Config Status: cfg=new, avail=yes, need=no, active=unknown

29: None 03.0: 10701 Ethernet
              [Created at net.126]
              Unique ID: U2Mp.ndpeucax6V1
              Parent ID: vWuh.VIRhsc57kTD
              SysFS ID: /class/net/ens3
              SysFS Device Link: /devices/pci0000:00/0000:00:03.0/virtio0
              Hardware Class: network interface
              Model: "Ethernet network interface"
              Driver: "virtio_net"
              Driver Modules: "virtio_net"
              Device File: ens3
              HW Address: 52:54:00:12:34:56
              Permanent HW Address: 52:54:00:12:34:56
              Link detected: yes
              Config Status: cfg=new, avail=yes, need=no, active=unknown
              Attached to: #19 (Ethernet controller)
        """
        )
        self.assertEqual(
            devices._hwinfo_parse_full(hwinfo),
            {
                "28": {
                    "None 00.0": "10700 Loopback",
                    "Note": "Created at net.126",
                    "Unique ID": "ZsBS.GQNx7L4uPNA",
                    "SysFS ID": "/class/net/lo",
                    "Hardware Class": "network interface",
                    "Model": "Loopback network interface",
                    "Device File": "lo",
                    "Link detected": "yes",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                },
                "29": {
                    "None 03.0": "10701 Ethernet",
                    "Note": "Created at net.126",
                    "Unique ID": "U2Mp.ndpeucax6V1",
                    "Parent ID": "vWuh.VIRhsc57kTD",
                    "SysFS ID": "/class/net/ens3",
                    "SysFS Device Link": "/devices/pci0000:00/0000:00:03.0/virtio0",
                    "Hardware Class": "network interface",
                    "Model": "Ethernet network interface",
                    "Driver": ["virtio_net"],
                    "Driver Modules": ["virtio_net"],
                    "Device File": "ens3",
                    "HW Address": "52:54:00:12:34:56",
                    "Permanent HW Address": "52:54:00:12:34:56",
                    "Link detected": "yes",
                    "Config Status": {
                        "cfg": "new",
                        "avail": "yes",
                        "need": "no",
                        "active": "unknown",
                    },
                    "Attached to": {"Handle": "#19 (Ethernet controller)"},
                },
            },
        )
07070100000087000081A40000427000000032000000015F4E04F800000530000000000000000000000000000000000000003500000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_disk.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import unittest

from utils import disk

class DiskTestCase(unittest.TestCase):
    def test_units(self):
        self.assertEqual(disk.units(1), (1, "MB"))
        self.assertEqual(disk.units("1"), (1, "MB"))
        self.assertEqual(disk.units("1.0"), (1, "MB"))
        self.assertEqual(disk.units("1s"), (1, "s"))
        self.assertEqual(disk.units("1.1s"), (1.1, "s"))
        self.assertRaises(disk.ParseException, disk.units, "s1")
07070100000088000081A40000427000000032000000015F4E04F80000332E000000000000000000000000000000000000003700000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_images.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import unittest
from unittest.mock import patch, MagicMock

from salt.exceptions import SaltInvocationError, CommandExecutionError

from modules import images

class ImagesTestCase(unittest.TestCase):
    def test__checksum_url(self):
        """Test images._checksum_url function"""
        self.assertEqual(
            images._checksum_url("http://example.com/image.xz", "md5"),
            "http://example.com/image.md5",
        )
        self.assertEqual(
            images._checksum_url("http://example.com/image.ext4", "md5"),
            "http://example.com/image.ext4.md5",
        )

def test__curl_cmd(self):
        """Test images._curl_cmd function"""
        self.assertEqual(
            images._curl_cmd("http://example.com/image.xz"),
            ["curl", "http://example.com/image.xz"],
        )
        self.assertEqual(
            images._curl_cmd("http://example.com/image.xz", s=None),
            ["curl", "-s", "http://example.com/image.xz"],
        )
        self.assertEqual(
            images._curl_cmd("http://example.com/image.xz", s="a"),
            ["curl", "-s", "a", "http://example.com/image.xz"],
        )
        self.assertEqual(
            images._curl_cmd("http://example.com/image.xz", _long=None),
            ["curl", "--_long", "http://example.com/image.xz"],
        )
        self.assertEqual(
            images._curl_cmd("http://example.com/image.xz", _long="a"),
            ["curl", "--_long", "a", "http://example.com/image.xz"],
        )

def test__fetch_file(self):
        """Test images._fetch_file function"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="stdout"),
        }

with patch.dict(images.__salt__, salt_mock):
            self.assertEqual(images._fetch_file("http://url"), "stdout")
            salt_mock["cmd.run_stdout"].assert_called_with(
                ["curl", "--silent", "--location", "http://url"]
            )

with patch.dict(images.__salt__, salt_mock):
            self.assertEqual(images._fetch_file("http://url", s="a"), "stdout")
            salt_mock["cmd.run_stdout"].assert_called_with(
                ["curl", "--silent", "--location", "-s", "a", "http://url"]
            )

def test__find_filesystem(self):
        """Test images._find_filesystem function"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="ext4"),
        }

with patch.dict(images.__salt__, salt_mock):
            self.assertEqual(images._find_filesystem("/dev/sda1"), "ext4")
            salt_mock["cmd.run_stdout"].assert_called_with(
                ["lsblk", "--noheadings", "--output", "FSTYPE", "/dev/sda1"]
            )

def test_fetch_checksum(self):
        """Test images.fetch_checksum function"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="mychecksum -"),
        }

with patch.dict(images.__salt__, salt_mock):
            self.assertEqual(
                images.fetch_checksum("http://url/image.xz", checksum_type="md5"),
                "mychecksum",
            )
            salt_mock["cmd.run_stdout"].assert_called_with(
                ["curl", "--silent", "--location", "http://url/image.md5"]
            )

with patch.dict(images.__salt__, salt_mock):
            self.assertEqual(
                images.fetch_checksum("http://url/image.ext4", checksum_type="md5"),
                "mychecksum",
            )
            salt_mock["cmd.run_stdout"].assert_called_with(
                ["curl", "--silent", "--location", "http://url/image.ext4.md5"]
            )

with patch.dict(images.__salt__, salt_mock):
            self.assertEqual(
                images.fetch_checksum(
                    "http://url/image.xz", checksum_type="sha1", s="a"
                ),
                "mychecksum",
            )
            salt_mock["cmd.run_stdout"].assert_called_with(
                ["curl", "--silent", "--location", "-s", "a", "http://url/image.sha1"]
            )

def test_dump_invalid_url(self):
        """Test images.dump function with an invalid URL"""
        with self.assertRaises(SaltInvocationError):
            images.dump("random://example.org", "/dev/sda1")

def test_dump_invalid_checksum_type(self):
        """Test images.dump function with an invalid checksum type"""
        with self.assertRaises(SaltInvocationError):
            images.dump("http://example.org/image.xz", "/dev/sda1", checksum_type="crc")

def test_dump_missing_checksum_type(self):
        """Test images.dump function with a missing checksum type"""
        with self.assertRaises(SaltInvocationError):
            images.dump(
                "http://example.org/image.xz", "/dev/sda1", checksum="mychecksum"
            )

def test_dump_download_fail(self):
        """Test images.dump function when download fails"""
        salt_mock = {
            "cmd.run_all": MagicMock(return_value={"retcode": 1, "stderr": "error"}),
        }

with patch.dict(images.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                images.dump("http://example.org/image.ext4", "/dev/sda1")
            salt_mock["cmd.run_all"].assert_called_with(
                "set -eo pipefail ; curl --fail --location --silent "
                "http://example.org/image.ext4 | tee /dev/sda1 "
                "| md5sum",
                python_shell=True,
            )

def test_dump_download_fail_gz(self):
        """Test images.dump function when download fails (gz)"""
        salt_mock = {
            "cmd.run_all": MagicMock(return_value={"retcode": 1, "stderr": "error"}),
        }

with patch.dict(images.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                images.dump("http://example.org/image.gz", "/dev/sda1")
            salt_mock["cmd.run_all"].assert_called_with(
                "set -eo pipefail ; curl --fail --location --silent "
                "http://example.org/image.gz | gunzip | tee /dev/sda1 "
                "| md5sum",
                python_shell=True,
            )

def test_dump_download_fail_bz2(self):
        """Test images.dump function when download fails (bz2)"""
        salt_mock = {
            "cmd.run_all": MagicMock(return_value={"retcode": 1, "stderr": "error"}),
        }

with patch.dict(images.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                images.dump("http://example.org/image.bz2", "/dev/sda1")
            salt_mock["cmd.run_all"].assert_called_with(
                "set -eo pipefail ; curl --fail --location --silent "
                "http://example.org/image.bz2 | bzip2 -d | tee /dev/sda1 "
                "| md5sum",
                python_shell=True,
            )

def test_dump_download_fail_xz(self):
        """Test images.dump function when download fails (xz)"""
        salt_mock = {
            "cmd.run_all": MagicMock(return_value={"retcode": 1, "stderr": "error"}),
        }

with patch.dict(images.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                images.dump("http://example.org/image.xz", "/dev/sda1")
            salt_mock["cmd.run_all"].assert_called_with(
                "set -eo pipefail ; curl --fail --location --silent "
                "http://example.org/image.xz | xz -d | tee /dev/sda1 "
                "| md5sum",
                python_shell=True,
            )

def test_dump_download_checksum_fail(self):
        """Test images.dump function when checksum fails"""
        salt_mock = {
            "cmd.run_all": MagicMock(
                return_value={"retcode": 0, "stdout": "badchecksum"}
            ),
        }

def test_dump_download_checksum_fail_fetch(self):
        """Test images.dump function when checksum fails"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="checksum -"),
            "cmd.run_all": MagicMock(
                return_value={"retcode": 0, "stdout": "badchecksum"}
            ),
        }

def test_dump_resize_fail_extx(self):
        """Test images.dump function when resize fails (extx)"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="ext4"),
            "cmd.run_all": MagicMock(
                side_effect=[
                    {"retcode": 0, "stdout": "checksum"},
                    {"retcode": 1, "stderr": "error"},
                ]
            ),
        }

with patch.dict(images.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                images.dump(
                    "http://example.org/image.ext4",
                    "/dev/sda1",
                    checksum_type="md5",
                    checksum="checksum",
                )
            salt_mock["cmd.run_all"].assert_called_with(
                "e2fsck -f -y /dev/sda1; resize2fs /dev/sda1", python_shell=True
            )

def test_dump_resize_fail_btrfs(self):
        """Test images.dump function when resize fails (btrfs)"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="btrfs"),
            "cmd.run_all": MagicMock(
                side_effect=[
                    {"retcode": 0, "stdout": "checksum"},
                    {"retcode": 1, "stderr": "error"},
                ]
            ),
        }

with patch.dict(images.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                images.dump(
                    "http://example.org/image.btrfs",
                    "/dev/sda1",
                    checksum_type="md5",
                    checksum="checksum",
                )
            salt_mock["cmd.run_all"].assert_called_with(
                "mount /dev/sda1 /mnt; btrfs filesystem resize max /mnt; "
                "umount /mnt",
                python_shell=True,
            )

def test_dump_resize_fail_xfs(self):
        """Test images.dump function when resize fails (xfs)"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="xfs"),
            "cmd.run_all": MagicMock(
                side_effect=[
                    {"retcode": 0, "stdout": "checksum"},
                    {"retcode": 1, "stderr": "error"},
                ]
            ),
        }

with patch.dict(images.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                images.dump(
                    "http://example.org/image.xfs",
                    "/dev/sda1",
                    checksum_type="md5",
                    checksum="checksum",
                )
            salt_mock["cmd.run_all"].assert_called_with(
                "mount /dev/sda1 /mnt; xfs_growfs /mnt; umount /mnt", python_shell=True
            )

def test_dump_resize(self):
        """Test images.dump function"""
        salt_mock = {
            "cmd.run_stdout": MagicMock(return_value="ext4"),
            "cmd.run_all": MagicMock(
                side_effect=[{"retcode": 0, "stdout": "checksum"}, {"retcode": 0}]
            ),
            "cmd.run": MagicMock(return_value=""),
        }

with patch.dict(images.__salt__, salt_mock):
            self.assertEqual(
                images.dump(
                    "http://example.org/image.ext4",
                    "/dev/sda1",
                    checksum_type="md5",
                    checksum="checksum",
                ),
                "checksum",
            )
            salt_mock["cmd.run"].assert_called_with("sync")
07070100000089000081A40000427000000032000000015F4E04F800005276000000000000000000000000000000000000003300000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_lp.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import unittest

from utils import lp

class ModelTestCase(unittest.TestCase):
    def test_add_constraint_fails(self):
        """Test Model.add_constraint asserts."""
        model = lp.Model(["x1", "x2"])
        self.assertRaises(AssertionError, model.add_constraint, [1], lp.EQ, 1)
        self.assertRaises(AssertionError, model.add_constraint, [1, 2, 3], lp.EQ, 1)
        self.assertRaises(AssertionError, model.add_constraint, [1, 2], None, 1)

def test_add_constraint(self):
        """Test Model.add_constraint success."""
        model = lp.Model(["x1", "x2"])
        model.add_constraint([1, 2], lp.EQ, 1)
        self.assertTrue(([1, 2], lp.EQ, 1) in model._constraints)

def test_add_cost_function_fails(self):
        """Test Model.add_cost_function asserts."""
        model = lp.Model(["x1", "x2"])
        self.assertRaises(AssertionError, model.add_cost_function, None, [1, 2], 1)
        self.assertRaises(AssertionError, model.add_cost_function, lp.MINIMIZE, [1], 1)
        self.assertRaises(
            AssertionError, model.add_cost_function, lp.MINIMIZE, [1, 2, 3], 1
        )

def test_add_cost_function(self):
        """Test Model.add_cost_function success."""
        model = lp.Model(["x1", "x2"])
        model.add_cost_function(lp.MINIMIZE, [1, 2], 1)
        self.assertEqual((lp.MINIMIZE, [1, 2], 1), model._cost_function)

def test__coeff(self):
        """Test model._coeff method."""
        model = lp.Model(["x1", "x2"])
        self.assertEqual(model._coeff({"x1": 1}), [1, 0])
        self.assertEqual(model._coeff({"x2": 1}), [0, 1])
        self.assertEqual(model._coeff({"x1": 1, "x2": 2}), [1, 2])

def test_add_constraint_named(self):
        """Test Model.add_constraint_named success."""
        model = lp.Model(["x1", "x2"])
        model.add_constraint_named({"x1": 1, "x2": 2}, lp.EQ, 1)
        self.assertTrue(([1, 2], lp.EQ, 1) in model._constraints)

def test_add_cost_function_named(self):
        """Test Model.add_cost_function success."""
        model = lp.Model(["x1", "x2"])
        model.add_cost_function_named(lp.MINIMIZE, {"x1": 1, "x2": 2}, 1)
        self.assertEqual((lp.MINIMIZE, [1, 2], 1), model._cost_function)

def test_simplex(self):
        """Test Model.simplex method."""
        model = lp.Model(["x1", "x2", "x3", "x4", "x5"])
        model.add_constraint([-6, 0, 1, -2, 2], lp.EQ, 6)
        model.add_constraint([-3, 1, 0, 6, 3], lp.EQ, 15)
        model.add_cost_function(lp.MINIMIZE, [5, 0, 0, 3, -2], -21)
        self.assertEqual(
            model.simplex(), {"x1": 1.0, "x2": 0.0, "x3": 0.0, "x4": 0.0, "x5": 6.0}
        )

def test__convert_to_standard_form_standard(self):
        """Test Model._convert_to_standard_form when in standard form."""
        model = lp.Model(["x1", "x2", "x3"])
        model.add_constraint([30, 100, 85], lp.EQ, 2500)
        model.add_constraint([6, 2, 3], lp.EQ, 90)
        model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
        model._convert_to_standard_form()
        self.assertEqual(model._slack_variables, [])
        self.assertEqual(
            model._standard_constraints, [([30, 100, 85], 2500), ([6, 2, 3], 90)]
        )
        self.assertEqual(model._standard_cost_function, ([3, 2, 4], 0))

def test__convert_to_standard_form_lte(self):
        """Test Model._convert_to_standard_form when constraint is LTE."""
        model = lp.Model(["x1", "x2", "x3"])
        model.add_constraint([30, 100, 85], lp.LTE, 2500)
        model.add_constraint([6, 2, 3], lp.EQ, 90)
        model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
        model._convert_to_standard_form()
        self.assertEqual(model._slack_variables, [3])
        self.assertEqual(
            model._standard_constraints, [([30, 100, 85, 1], 2500), ([6, 2, 3, 0], 90)]
        )
        self.assertEqual(model._standard_cost_function, ([3, 2, 4, 0], 0))

def test__convert_to_standard_form_gte(self):
        """Test Model._convert_to_standard_form when constraint is GTE."""
        model = lp.Model(["x1", "x2", "x3"])
        model.add_constraint([30, 100, 85], lp.GTE, 2500)
        model.add_constraint([6, 2, 3], lp.EQ, 90)
        model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
        model._convert_to_standard_form()
        self.assertEqual(model._slack_variables, [3])
        self.assertEqual(
            model._standard_constraints, [([30, 100, 85, -1], 2500), ([6, 2, 3, 0], 90)]
        )
        self.assertEqual(model._standard_cost_function, ([3, 2, 4, 0], 0))

def test__convert_to_standard_form_lte_gte(self):
        """Test Model._convert_to_standard_form for LTE/GTE constraints."""
        model = lp.Model(["x1", "x2", "x3"])
        model.add_constraint([30, 100, 85], lp.LTE, 2500)
        model.add_constraint([6, 2, 3], lp.GTE, 90)
        model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
        model._convert_to_standard_form()
        self.assertEqual(model._slack_variables, [3, 4])
        self.assertEqual(
            model._standard_constraints,
            [([30, 100, 85, 1, 0], 2500), ([6, 2, 3, 0, -1], 90)],
        )
        self.assertEqual(model._standard_cost_function, ([3, 2, 4, 0, 0], 0))

def test__convert_to_standard_form_maximize(self):
        """Test Model._convert_to_standard_form when maximizing."""
        model = lp.Model(["x1", "x2", "x3"])
        model.add_constraint([30, 100, 85], lp.EQ, 2500)
        model.add_constraint([6, 2, 3], lp.EQ, 90)
        model.add_cost_function(lp.MAXIMIZE, [3, 2, 4], 0)
        model._convert_to_standard_form()
        self.assertEqual(model._slack_variables, [])
        self.assertEqual(
            model._standard_constraints, [([30, 100, 85], 2500), ([6, 2, 3], 90)]
        )
        self.assertEqual(model._standard_cost_function, ([-3, -2, -4], 0))

def test__convert_to_canonical_form(self):
        """Test Model._convert_to_canonical_form when in standard form."""
        model = lp.Model(["x1", "x2", "x3", "x4"])
        model.add_constraint([1, -2, -3, -2], lp.EQ, 3)
        model.add_constraint([1, -1, 2, 1], lp.EQ, 11)
        model.add_cost_function(lp.MINIMIZE, [2, -3, 1, 1], 0)
        model._convert_to_standard_form()
        model._convert_to_canonical_form()
        self.assertEqual(
            model._canonical_constraints,
            [([1, -2, -3, -2, 1, 0], 3), ([1, -1, 2, 1, 0, 1], 11)],
        )
        self.assertEqual(model._canonical_cost_function, ([2, -3, 1, 1, 0, 0], 0))
        self.assertEqual(
            model._canonical_artificial_function, ([-2, 3, 1, 1, 0, 0], -14)
        )

def test__convert_to_canonical_form_neg_free_term(self):
        """Test Model._convert_to_standard_form when in standard form."""
        model = lp.Model(["x1", "x2", "x3"])
        model.add_constraint([30, 100, 85], lp.EQ, -2500)
        model.add_constraint([6, 2, 3], lp.EQ, 90)
        model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
        model._convert_to_standard_form()
        model._convert_to_canonical_form()
        self.assertEqual(
            model._canonical_constraints,
            [([-30, -100, -85, 1, 0], 2500), ([6, 2, 3, 0, 1], 90)],
        )
        self.assertEqual(model._canonical_cost_function, ([3, 2, 4, 0, 0], 0))
        self.assertEqual(
            model._canonical_artificial_function, ([24, 98, 82, 0, 0], -2590)
        )

def test__convert_to_canonical_form_artificial(self):
        """Test Model._convert_to_canonical_form when not in standard form."""
        model = lp.Model(["x1", "x2", "x3", "x4"])
        model.add_constraint([1, -2, -3, -2], lp.LTE, 3)
        model.add_constraint([1, -1, 2, 1], lp.GTE, 11)
        model.add_cost_function(lp.MAXIMIZE, [2, -3, 1, 1], 10)
        model._convert_to_standard_form()
        model._convert_to_canonical_form()
        self.assertEqual(
            model._canonical_constraints,
            [([1, -2, -3, -2, 1, 0, 1, 0], 3), ([1, -1, 2, 1, 0, -1, 0, 1], 11)],
        )
        self.assertEqual(
            model._canonical_cost_function, ([-2, 3, -1, -1, 0, 0, 0, 0], -10)
        )
        self.assertEqual(
            model._canonical_artificial_function, ([-2, 3, 1, 1, -1, 1, 0, 0], -14)
        )

def test__build_tableau_canonical_form(self):
        """Test Model._build_tableau_canonical_form method."""
        model = lp.Model(["x1", "x2", "x3", "x4"])
        model.add_constraint([1, -2, -3, -2], lp.EQ, 3)
        model.add_constraint([1, -1, 2, 1], lp.EQ, 11)
        model.add_cost_function(lp.MINIMIZE, [2, -3, 1, 1], 0)
        model._convert_to_standard_form()
        model._convert_to_canonical_form()
        tableau = model._build_tableau_canonical_form()
        self.assertEqual(tableau._basic_variables, [4, 5])
        self.assertEqual(
            tableau._tableau,
            [
                [1, -2, -3, -2, 1, 0, 3],
                [1, -1, 2, 1, 0, 1, 11],
                [2, -3, 1, 1, 0, 0, 0],
                [-2, 3, 1, 1, 0, 0, -14],
            ],
        )

def test___str__(self):
        """Test Model.__str__ method."""
        model = lp.Model(["x1", "x2", "x3", "x4", "x5"])
        model.add_constraint([-6, 0, 1, -2, 2], lp.LTE, 6)
        model.add_constraint([-3, 1, 0, 6, 3], lp.EQ, 15)
        model.add_cost_function(lp.MINIMIZE, [5, 0, 0, 3, -2], -21)
        self.assertEqual(
            model.__str__(),
            """Minimize:
  5 x1 + 0 x2 + 0 x3 + 3 x4 - 2 x5 - 21

Subject to:
  -6 x1 + 0 x2 + 1 x3 - 2 x4 + 2 x5 <= 6
  -3 x1 + 1 x2 + 0 x3 + 6 x4 + 3 x5 = 15
  x1, x2, x3, x4, x5 >= 0""",
        )

class TableauTestCase(unittest.TestCase):
    def test_add_constraint_fails(self):
        """Test Tableau.add_constraint asserts."""
        tableau = lp.Tableau(3, 2)
        self.assertRaises(AssertionError, tableau.add_constraint, [1], 0)
        self.assertRaises(AssertionError, tableau.add_constraint, [1, 2, 3, 4, 5], 0)
        tableau.add_constraint([1, 2, 3, 4], 0)
        self.assertRaises(AssertionError, tableau.add_constraint, [1, 2, 3, 4], 0)

def test_add_constraint(self):
        """Test Tableau.add_constraint success."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        self.assertEqual(tableau._basic_variables, [0])
        self.assertEqual(tableau._tableau, [[1, 2, 3, 4]])

def test_add_cost_function_fails(self):
        """Test Tableau.add_cost_function asserts."""
        tableau = lp.Tableau(3, 2)
        self.assertRaises(AssertionError, tableau.add_cost_function, [1])
        self.assertRaises(AssertionError, tableau.add_cost_function, [1, 2, 3, 4])

def test_add_cost_function(self):
        """Test Tableau.add_cost_function success."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, 1, 2])
        self.assertEqual(tableau._tableau, [[1, 2, 3, 4], [0, 1, 2, 3], [0, 0, 1, 2]])

def test_add_artificial_function_fails(self):
        """Test Tableau.add_artificial_function asserts."""
        tableau = lp.Tableau(3, 2)
        self.assertRaises(AssertionError, tableau.add_artificial_function, [1])
        self.assertRaises(AssertionError, tableau.add_artificial_function, [1, 2, 3, 4])

def test_add_artificial_function(self):
        """Test Tableau.add_artificial_function success."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, 1, 2])
        tableau.add_artificial_function([1, 3, 5, 7])
        self.assertTrue(tableau._artificial)
        self.assertEqual(
            tableau._tableau, [[1, 2, 3, 4], [0, 1, 2, 3], [0, 0, 1, 2], [1, 3, 5, 7]]
        )

def test_constraints(self):
        """Test Tableau.constraints method."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, 1, 2])
        tableau.add_artificial_function([1, 3, 5, 7])
        self.assertEqual(tableau.constraints(), [[1, 2, 3, 4], [0, 1, 2, 3]])

def test_cost_function(self):
        """Test Tableau.cost_function for non artificial models."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, 1, 2])
        self.assertEqual(tableau.cost_function(), [0, 0, 1, 2])

def test_cost_function_artificial(self):
        """Test Tableau.cost_function for artificial models."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, 1, 2])
        tableau.add_artificial_function([1, 3, 5, 7])
        self.assertEqual(tableau.cost_function(), [1, 3, 5, 7])

def test_drop_artificial_not_minimal(self):
        """Test Tableau.drop_artificial fails when not minimal."""
        tableau = lp.Tableau(4, 2)
        tableau.add_constraint([1, 2, 1, 0, 5], 0)
        tableau.add_constraint([0, 1, 0, 1, 5], 1)
        tableau.add_cost_function([2, 3, 0, 0, 5])
        tableau.add_artificial_function([-1, -3, 0, 0, -15])
        self.assertRaises(AssertionError, tableau.drop_artificial)

def test_drop_artificial_artificial_variable(self):
        """Test Tableau.drop_artificial fails when artificial variable."""
        tableau = lp.Tableau(4, 2)
        tableau.add_constraint([1, 2, 1, 0, 5], 2)
        tableau.add_constraint([0, 1, 0, 1, 5], 3)
        tableau.add_cost_function([2, 3, 0, 0, 5])
        tableau.add_artificial_function([1, 3, 0, 0, -15])
        self.assertRaises(AssertionError, tableau.drop_artificial)

def test_drop_artificial(self):
        """Test Tableau.drop_artificial method."""
        tableau = lp.Tableau(4, 2)
        tableau.add_constraint([1, 2, 1, 0, 5], 0)
        tableau.add_constraint([0, 1, 0, 1, 5], 1)
        tableau.add_cost_function([2, 3, 0, 0, 5])
        tableau.add_artificial_function([1, 3, 0, 0, -15])
        tableau.drop_artificial()
        self.assertFalse(tableau._artificial)
        self.assertEqual(tableau._tableau, [[1, 2, 5], [0, 1, 5], [2, 3, 5]])

def test_simplex(self):
        """Test Tableau.simplex method."""
        tableau = lp.Tableau(5, 2)
        tableau.add_constraint([-6, 0, 1, -2, 2, 6], 2)
        tableau.add_constraint([-3, 1, 0, 6, 3, 15], 1)
        tableau.add_cost_function([5, 0, 0, 3, -2, -21])
        tableau.simplex()
        self.assertEqual(tableau._basic_variables, [4, 0])
        self.assertEqual(
            tableau._tableau,
            [
                [0.0, 1 / 2, -1 / 4, 7 / 2, 1.0, 6.0],
                [1.0, 1 / 6, -1 / 4, 3 / 2, 0.0, 1.0],
                [0.0, 1 / 6, 3 / 4, 5 / 2, 0.0, -14.0],
            ],
        )

def test_is_canonical_not_canonical(self):
        """Test Tableau.is_canonical when not canonical."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 0, 5], 1)
        tableau.add_constraint([0, 1, 0, 5], 2)
        tableau.add_cost_function([2, 3, 0, 5])
        self.assertFalse(tableau.is_canonical())

def test_is_canonical_almost_canonical(self):
        """Test Tableau.is_canonical when no canonical."""
        tableau = lp.Tableau(2, 2)
        tableau.add_constraint([1, 2, 5], 0)
        tableau.add_constraint([0, 1, 5], 1)
        tableau.add_cost_function([2, 3, 5])
        self.assertFalse(tableau.is_canonical())

def test_is_canonical(self):
        """Test Tableau.is_canonical when canonical."""
        tableau = lp.Tableau(2, 2)
        tableau.add_constraint([1, 0, 5], 0)
        tableau.add_constraint([0, 1, 5], 1)
        tableau.add_cost_function([0, 0, 5])
        self.assertTrue(tableau.is_canonical())

def test_is_minimum_not_minimum(self):
        """Test Tableau.is_minimum method."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, -1, 2])
        self.assertFalse(tableau.is_minimum())

def test_is_minimum_artificial_not_minimum(self):
        """Test Tableau.is_minimum method."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, 1, 2])
        tableau.add_artificial_function([2, -3, 0, 0])
        self.assertFalse(tableau.is_minimum())

def test_is_minimum(self):
        """Test Tableau.is_minimum method."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, 1, 2])
        self.assertTrue(tableau.is_minimum())

def test_is_minimum_artificial(self):
        """Test Tableau.is_minimum method."""
        tableau = lp.Tableau(3, 2)
        tableau.add_constraint([1, 2, 3, 4], 0)
        tableau.add_constraint([0, 1, 2, 3], 1)
        tableau.add_cost_function([0, 0, -1, 2])
        tableau.add_artificial_function([2, 3, 0, 0])
        self.assertTrue(tableau.is_minimum())

def test_is_basic_feasible_solution_fails(self):
        """Test Tableau.is_basic_feasible_solution failures."""
        tableau = lp.Tableau(4, 2)
        tableau.add_constraint([1, 1, 2, 1, 6], 0)
        tableau.add_constraint([0, 3, 1, 8, 3], 1)
        tableau.add_cost_function([0, 0, 0, 0, 0])
        self.assertRaises(AssertionError, tableau.is_basic_feasible_solution)

def test_is_basic_feasible_solution_non_existent(self):
        """Test Tableau.is_basic_feasible_solution method."""
        tableau = lp.Tableau(4, 2)
        tableau.add_constraint([1, 0, 1.667, 1.667, 5], 0)
        tableau.add_constraint([0, 1, 0.333, 2.667, -1], 1)
        tableau.add_cost_function([0, 0, 0, 0, 0])
        self.assertFalse(tableau.is_basic_feasible_solution())

def test_is_basic_feasible_solution(self):
        """Test Tableau.is_basic_feasible_solution method."""
        tableau = lp.Tableau(4, 2)
        tableau.add_constraint([1, 0, 1.667, 1.667, 5], 0)
        tableau.add_constraint([0, 1, 0.333, 2.667, 1], 1)
        tableau.add_cost_function([0, 0, 0, 0, 0])
        self.assertTrue(tableau.is_basic_feasible_solution())

def test_is_bound(self):
        """Test Tableau.is_bound method."""
        pass

def test__get_pivoting_column(self):
        """Test Tableau._get_pivoting_column method."""
        tableau = lp.Tableau(5, 2)
        tableau.add_constraint([-6, 0, 1, -2, 2, 6], 2)
        tableau.add_constraint([-3, 1, 0, 6, 3, 15], 1)
        tableau.add_cost_function([5, 0, 0, 3, -2, -21])
        self.assertEqual(tableau._get_pivoting_column(), 4)

def test__get_pivoting_row(self):
        """Test Tableau._get_pivoting_row method."""
        tableau = lp.Tableau(5, 2)
        tableau.add_constraint([-6, 0, 1, -2, 2, 6], 2)
        tableau.add_constraint([-3, 1, 0, 6, 3, 15], 1)
        tableau.add_cost_function([5, 0, 0, 3, -2, -21])
        self.assertEqual(tableau._get_pivoting_row(4), 0)

def test__pivote(self):
        """Test Tableau._pivote method."""
        tableau = lp.Tableau(3, 3)
        tableau.add_constraint([1, 4, 2, 6], 0)
        tableau.add_constraint([3, 14, 8, 16], 1)
        tableau.add_constraint([4, 21, 10, 28], 2)

# Pivote by x1 in the first equation
        tableau._pivote(0, 0)
        self.assertEqual(
            tableau._tableau,
            [[1.0, 4.0, 2.0, 6.0], [0.0, 2.0, 2.0, -2.0], [0.0, 5.0, 2.0, 4.0]],
        )
        # Pivote by x2 in the second equation
        tableau._pivote(1, 1)
        self.assertEqual(
            tableau._tableau,
            [[1.0, 0.0, -2.0, 10.0], [0.0, 1.0, 1.0, -1.0], [0.0, 0.0, -3.0, 9.0]],
        )
        # Pivote by x3 in the third equation
        tableau._pivote(2, 2)
        self.assertEqual(
            tableau._tableau,
            [[1.0, 0.0, 0.0, 4.0], [0.0, 1.0, 0.0, 2.0], [0.0, 0.0, 1.0, -3.0]],
        )

if __name__ == "__main__":
    unittest.main()
0707010000008A000081A40000427000000032000000015F4E04F800003495000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_partitioned.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import unittest
from unittest.mock import patch

from states import partitioned

class PartitionedTestCase(unittest.TestCase):
    @patch("states.partitioned.__salt__")
    def test_check_label(self, __salt__):
        __salt__.__getitem__.return_value = lambda _: "Partition Table: msdos"
        self.assertTrue(partitioned._check_label("/dev/sda", "msdos"))
        self.assertTrue(partitioned._check_label("/dev/sda", "dos"))
        self.assertFalse(partitioned._check_label("/dev/sda", "gpt"))

__salt__.__getitem__.return_value = lambda _: ""
        self.assertFalse(partitioned._check_label("/dev/sda", "msdos"))
        self.assertFalse(partitioned._check_label("/dev/sda", "gpt"))

@patch("states.partitioned.__opts__")
    @patch("states.partitioned.__salt__")
    def test_labeled(self, __salt__, __opts__):
        __opts__.__getitem__.return_value = False

__salt__.__getitem__.return_value = lambda _: "Partition Table: msdos"
        self.assertEqual(
            partitioned.labeled("/dev/sda", "msdos"),
            {
                "name": "/dev/sda",
                "result": True,
                "changes": {},
                "comment": ["Label already set to msdos"],
            },
        )

__salt__.__getitem__.side_effect = (
            lambda _: "",
            lambda _a, _b: True,
            lambda _: "Partition Table: msdos",
        )
        self.assertEqual(
            partitioned.labeled("/dev/sda", "msdos"),
            {
                "name": "/dev/sda",
                "result": True,
                "changes": {"label": "Label set to msdos in /dev/sda"},
                "comment": ["Label set to msdos in /dev/sda"],
            },
        )

@patch("states.partitioned.__salt__")
    def test_get_partition_type(self, __salt__):
        __salt__.__getitem__.return_value = (
            lambda _: """
Model: ATA ST2000DM001-9YN1 (scsi)
Disk /dev/sda: 2000GB
Sector size (logical/physical): 512B/4096B
Partition Table: msdos
Disk Flags:

Number  Start   End     Size    Type     File system     Flags
 1      1049kB  2155MB  2154MB  primary  linux-swap(v1)  type=82
 2      2155MB  45.1GB  43.0GB  primary  btrfs           boot, type=83
 3      45.1GB  2000GB  1955GB  primary  xfs             type=83
        """
        )
        self.assertEqual(
            partitioned._get_partition_type("/dev/sda"),
            {"1": "primary", "2": "primary", "3": "primary"},
        )

__salt__.__getitem__.return_value = (
            lambda _: """
Model: ATA QEMU HARDDISK (scsi)
Disk /dev/sda: 25.8GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:

Number  Start   End     Size    Type      File system  Flags
 1      1049kB  11.5MB  10.5MB  extended               type=05
 5      2097kB  5243kB  3146kB  logical                type=83
 3      11.5GB  22.0MB  10.5MB  primary                type=83
        """
        )
        self.assertEqual(
            partitioned._get_partition_type("/dev/sda"),
            {"1": "extended", "5": "logical", "3": "primary"},
        )

@patch("states.partitioned.__salt__")
    def test_get_cached_partitions(self, __salt__):
        __salt__.__getitem__.side_effect = [
            lambda _: "1 extended",
            lambda _, unit: {"info": None, "partitions": {"1": {}}},
        ]

self.assertEqual(
            partitioned._get_cached_partitions("/dev/sda", "s"),
            {"1": {"type": "extended"}},
        )
        partitioned._invalidate_cached_partitions()

__salt__.__getitem__.side_effect = [
            lambda _: "",
            lambda _, unit: {"info": None, "partitions": {"1": {}}},
        ]

self.assertEqual(
            partitioned._get_cached_partitions("/dev/sda", "s"),
            {"1": {"type": "primary"}},
        )

@patch("states.partitioned._get_cached_partitions")
    def test_check_partition(self, _get_cached_partitions):
        _get_cached_partitions.return_value = {
            "1": {"type": "primary", "size": "10s", "start": "0s", "end": "10s"}
        }
        self.assertTrue(
            partitioned._check_partition("/dev/sda", 1, "primary", "0s", "10s")
        )
        self.assertTrue(
            partitioned._check_partition("/dev/sda", "1", "primary", "0s", "10s")
        )
        self.assertFalse(
            partitioned._check_partition("/dev/sda", "1", "primary", "10s", "20s")
        )
        self.assertEqual(
            partitioned._check_partition("/dev/sda", "2", "primary", "10s", "20s"), None
        )

_get_cached_partitions.return_value = {
            "1": {"type": "primary", "size": "100kB", "start": "0.5kB", "end": "100kB"}
        }
        self.assertTrue(
            partitioned._check_partition("/dev/sda", "1", "primary", "0kB", "100kB")
        )
        self.assertTrue(
            partitioned._check_partition("/dev/sda", "1", "primary", "1kB", "100kB")
        )
        self.assertFalse(
            partitioned._check_partition("/dev/sda", "1", "primary", "1.5kB", "100kB")
        )

@patch("states.partitioned._get_cached_partitions")
    def test_get_first_overlapping_partition(self, _get_cached_partitions):
        _get_cached_partitions.return_value = {}
        self.assertEqual(
            partitioned._get_first_overlapping_partition("/dev/sda", "0s"), None
        )

_get_cached_partitions.return_value = {
            "1": {
                "number": "1",
                "type": "primary",
                "size": "10s",
                "start": "0s",
                "end": "10s",
            }
        }
        self.assertEqual(
            partitioned._get_first_overlapping_partition("/dev/sda", "0s"), "1"
        )

_get_cached_partitions.return_value = {
            "1": {
                "number": "1",
                "type": "primary",
                "size": "100kB",
                "start": "0.51kB",
                "end": "100kB",
            }
        }
        self.assertEqual(
            partitioned._get_first_overlapping_partition("/dev/sda", "0kB"), "1"
        )

_get_cached_partitions.return_value = {
            "1": {
                "number": "1",
                "type": "extended",
                "size": "10s",
                "start": "0s",
                "end": "10s",
            },
            "5": {
                "number": "5",
                "type": "logical",
                "size": "4s",
                "start": "1s",
                "end": "5s",
            },
        }
        self.assertEqual(
            partitioned._get_first_overlapping_partition("/dev/sda", "0s"), "1"
        )

self.assertEqual(
            partitioned._get_first_overlapping_partition("/dev/sda", "1s"), "5"
        )

@patch("states.partitioned._get_cached_info")
    @patch("states.partitioned._get_cached_partitions")
    def test_get_partition_number_primary(
        self, _get_cached_partitions, _get_cached_info
    ):
        _get_cached_info.return_value = {"partition table": "msdos"}
        _get_cached_partitions.return_value = {}

partition_data = ("/dev/sda", "primary", "0s", "10s")
        self.assertEqual(partitioned._get_partition_number(*partition_data), "1")

_get_cached_partitions.return_value = {
            "1": {
                "number": "1",
                "type": "primary",
                "size": "10s",
                "start": "0s",
                "end": "10s",
            }
        }
        self.assertEqual(partitioned._get_partition_number(*partition_data), "1")

partition_data = ("/dev/sda", "primary", "0s", "10s")
        self.assertEqual(partitioned._get_partition_number(*partition_data), "1")

partition_data = ("/dev/sda", "primary", "41s", "50s")
        self.assertRaises(
            partitioned.EnumerateException,
            partitioned._get_partition_number,
            *partition_data
        )

_get_cached_info.return_value = {"partition table": "gpt"}
        partition_data = ("/dev/sda", "primary", "41s", "50s")
        self.assertEqual(partitioned._get_partition_number(*partition_data), "5")

@patch("states.partitioned._get_cached_info")
    @patch("states.partitioned._get_cached_partitions")
    def test_get_partition_number_extended(
        self, _get_cached_partitions, _get_cached_info
    ):
        _get_cached_info.return_value = {"partition table": "msdos"}
        _get_cached_partitions.return_value = {}
        partition_data = ("/dev/sda", "extended", "0s", "10s")
        self.assertEqual(partitioned._get_partition_number(*partition_data), "1")

_get_cached_partitions.return_value = {
            "1": {"number": "1", "type": "primary", "start": "0s", "end": "10s"},
        }
        partition_data = ("/dev/sda", "extended", "21s", "30s")
        self.assertEqual(partitioned._get_partition_number(*partition_data), "2")

_get_cached_partitions.return_value = {
            "1": {"number": "1", "type": "primary", "start": "0s", "end": "10s"},
            "2": {"number": "2", "type": "extended", "start": "11s", "end": "20s"},
        }
        self.assertRaises(
            partitioned.EnumerateException,
            partitioned._get_partition_number,
            *partition_data
        )

_get_cached_partitions.return_value = {
            "1": {"number": "1", "type": "primary", "start": "0s", "end": "10s"},
            "2": {"number": "2", "type": "primary", "start": "11s", "end": "20s"},
            "3": {"number": "3", "type": "primary", "start": "21s", "end": "30s"},
            "4": {"number": "4", "type": "primary", "start": "31s", "end": "40s"},
        }
        partition_data = ("/dev/sda", "extended", "41s", "50s")
        self.assertRaises(
            partitioned.EnumerateException,
            partitioned._get_partition_number,
            *partition_data
        )

_get_cached_info.return_value = {"partition table": "gpt"}
        _get_cached_partitions.return_value = {}
        self.assertRaises(
            partitioned.EnumerateException,
            partitioned._get_partition_number,
            *partition_data
        )

@patch("states.partitioned._get_cached_info")
    @patch("states.partitioned._get_cached_partitions")
    def test_get_partition_number_logial(
        self, _get_cached_partitions, _get_cached_info
    ):
        _get_cached_info.return_value = {"partition table": "msdos"}
        _get_cached_partitions.return_value = {}
        partition_data = ("/dev/sda", "logical", "0s", "10s")
        self.assertRaises(
            partitioned.EnumerateException,
            partitioned._get_partition_number,
            *partition_data
        )

_get_cached_partitions.return_value = {
            "1": {"number": "1", "type": "primary", "start": "0s", "end": "10s"},
        }
        partition_data = ("/dev/sda", "logical", "12s", "15s")
        self.assertRaises(
            partitioned.EnumerateException,
            partitioned._get_partition_number,
            *partition_data
        )

_get_cached_partitions.return_value = {
            "1": {"number": "1", "type": "primary", "start": "0s", "end": "10s"},
            "2": {"number": "2", "type": "extended", "start": "11s", "end": "20s"},
        }
        self.assertEqual(partitioned._get_partition_number(*partition_data), "5")

_get_cached_partitions.return_value = {
            "1": {"number": "1", "type": "primary", "start": "0s", "end": "10s"},
            "2": {"number": "2", "type": "extended", "start": "11s", "end": "20s"},
            "5": {"number": "5", "type": "logical", "start": "12s", "end": "15s"},
        }
        self.assertEqual(partitioned._get_partition_number(*partition_data), "5")

partition_data = ("/dev/sda", "logical", "16s", "19s")
        self.assertEqual(partitioned._get_partition_number(*partition_data), "6")

@patch("states.partitioned._get_partition_number")
    @patch("states.partitioned.__salt__")
    def test_mkparted(self, __salt__, _get_partition_number):
        pass

if __name__ == "__main__":
    unittest.main()
0707010000008B000081A40000427000000032000000015F4E04F800006162000000000000000000000000000000000000003800000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_partmod.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import unittest
from unittest.mock import patch

from salt.exceptions import SaltInvocationError

from disk import ParseException
from modules import partmod
from modules import filters

class PartmodTestCase(unittest.TestCase):
    @patch("modules.partmod.__grains__")
    def test_prepare_partition_data_fails_fs_type(self, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "error"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        with self.assertRaises(SaltInvocationError) as cm:
            partmod.prepare_partition_data(partitions)
        self.assertTrue("type error not recognized" in str(cm.exception))

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_fails_units_invalid(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "1Kilo", "type": "swap"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        with self.assertRaises(ParseException) as cm:
            partmod.prepare_partition_data(partitions)
        self.assertTrue("Kilo not recognized" in str(cm.exception))

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_fails_units_initial_gap(self, __salt__, __grains__):
        partitions = {
            "config": {"initial_gap": "1024kB"},
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "1MB", "type": "swap"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        with self.assertRaises(SaltInvocationError) as cm:
            partmod.prepare_partition_data(partitions)
        self.assertTrue("Units needs to be" in str(cm.exception))

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_bios_no_gap(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_bios_msdos_no_gap(self, __salt__, __grains__):
        partitions = {
            "config": {"label": "msdos"},
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_bios_local_msdos_no_gap(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "label": "msdos",
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_bios_gpt_no_gap(self, __salt__, __grains__):
        partitions = {
            "config": {"label": "gpt"},
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "gpt",
                    "pmbr_boot": True,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_bios_local_gpt_no_gap(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "label": "gpt",
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "gpt",
                    "pmbr_boot": True,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_gap(self, __salt__, __grains__):
        partitions = {
            "config": {"initial_gap": "1MB"},
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "1.0MB",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_local_gap(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "initial_gap": "1MB",
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "1.0MB",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_fails_rest(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "partitions": [
                        {"number": 1, "size": "rest", "type": "swap"},
                        {"number": 2, "size": "rest", "type": "linux"},
                    ],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        with self.assertRaises(SaltInvocationError) as cm:
            partmod.prepare_partition_data(partitions)
        self.assertTrue("rest free space" in str(cm.exception))

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_fails_units(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "partitions": [
                        {"number": 1, "size": "1%", "type": "swap"},
                        {"number": 2, "size": "2MB", "type": "linux"},
                    ],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        with self.assertRaises(SaltInvocationError) as cm:
            partmod.prepare_partition_data(partitions)
        self.assertTrue("Units needs to be" in str(cm.exception))

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_efi_partitions(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "label": "gpt",
                    "partitions": [
                        {"number": 1, "size": "500MB", "type": "efi"},
                        {"number": 2, "size": "10000MB", "type": "linux"},
                        {"number": 3, "size": "5000MB", "type": "swap"},
                    ],
                },
            },
        }
        __grains__.__getitem__.return_value = True
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "gpt",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "fat16",
                            "flags": ["esp"],
                            "start": "0MB",
                            "end": "500.0MB",
                        },
                        {
                            "part_id": "/dev/sda2",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "500.0MB",
                            "end": "10500.0MB",
                        },
                        {
                            "part_id": "/dev/sda3",
                            "part_type": "primary",
                            "fs_type": "linux-swap",
                            "flags": None,
                            "start": "10500.0MB",
                            "end": "15500.0MB",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_bios_muti_label(self, __salt__, __grains__):
        partitions = {
            "config": {"label": "msdos"},
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
                "/dev/sdb": {
                    "label": "gpt",
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
                "/dev/sdb": {
                    "label": "gpt",
                    "pmbr_boot": True,
                    "partitions": [
                        {
                            "part_id": "/dev/sdb1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_multi_gap(self, __salt__, __grains__):
        partitions = {
            "config": {"initial_gap": "1MB"},
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
                "/dev/sdb": {
                    "initial_gap": "2MB",
                    "partitions": [{"number": 1, "size": "20MB", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "1.0MB",
                            "end": "100%",
                        },
                    ],
                },
                "/dev/sdb": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sdb1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "2.0MB",
                            "end": "22.0MB",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_lvm(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "lvm"}],
                },
                "/dev/sdb": {
                    "partitions": [{"number": 1, "size": "rest", "type": "lvm"}],
                },
                "/dev/sdc": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": ["lvm"],
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
                "/dev/sdb": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sdb1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": ["lvm"],
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
                "/dev/sdc": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sdc1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_raid(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/sda": {
                    "partitions": [{"number": 1, "size": "rest", "type": "raid"}],
                },
                "/dev/sdb": {
                    "partitions": [{"number": 1, "size": "rest", "type": "raid"}],
                },
                "/dev/sdc": {
                    "partitions": [{"number": 1, "size": "rest", "type": "linux"}],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/sda": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sda1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": ["raid"],
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
                "/dev/sdb": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sdb1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": ["raid"],
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
                "/dev/sdc": {
                    "label": "msdos",
                    "pmbr_boot": False,
                    "partitions": [
                        {
                            "part_id": "/dev/sdc1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "0%",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

@patch("modules.partmod.__grains__")
    @patch("modules.partmod.__salt__")
    def test_prepare_partition_data_bios_gpt_post_raid(self, __salt__, __grains__):
        partitions = {
            "devices": {
                "/dev/md0": {
                    "label": "gpt",
                    "partitions": [
                        {"number": 1, "size": "8MB", "type": "boot"},
                        {"number": 2, "size": "rest", "type": "linux"},
                    ],
                },
            },
        }
        __grains__.__getitem__.return_value = False
        __salt__.__getitem__.return_value = filters.is_raid
        self.assertEqual(
            partmod.prepare_partition_data(partitions),
            {
                "/dev/md0": {
                    "label": "gpt",
                    "pmbr_boot": True,
                    "partitions": [
                        {
                            "part_id": "/dev/md0p1",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": ["bios_grub"],
                            "start": "0MB",
                            "end": "8.0MB",
                        },
                        {
                            "part_id": "/dev/md0p2",
                            "part_type": "primary",
                            "fs_type": "ext2",
                            "flags": None,
                            "start": "8.0MB",
                            "end": "100%",
                        },
                    ],
                },
            },
        )

if __name__ == "__main__":
    unittest.main()
0707010000008C000081A40000427000000032000000015F4E04F8000040D8000000000000000000000000000000000000004200000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_state_suseconnect.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations

import unittest
from unittest.mock import patch, MagicMock

from states import suseconnect

from salt.exceptions import CommandExecutionError

class SUSEConnectTestCase(unittest.TestCase):
    def test__status_registered(self):
        salt_mock = {
            "suseconnect.status": MagicMock(
                return_value=[
                    {
                        "identifier": "SLES",
                        "version": "15.2",
                        "arch": "x86_64",
                        "status": "Registered",
                        "subscription_status": "ACTIVE",
                    },
                    {
                        "identifier": "sle-module-basesystem",
                        "version": "15.2",
                        "arch": "x86_64",
                        "status": "Registered",
                    },
                    {
                        "identifier": "sle-module-server-applications",
                        "version": "15.2",
                        "arch": "x86_64",
                        "status": "Registered",
                    },
                ]
            ),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect._status(None),
                (
                    [
                        "SLES/15.2/x86_64",
                        "sle-module-basesystem/15.2/x86_64",
                        "sle-module-server-applications/15.2/x86_64",
                    ],
                    ["SLES/15.2/x86_64"],
                ),
            )

def test__status_unregistered(self):
        salt_mock = {
            "suseconnect.status": MagicMock(
                return_value=[
                    {
                        "identifier": "openSUSE",
                        "version": "20191014",
                        "arch": "x86_64",
                        "status": "Not Registered",
                    },
                ]
            ),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(suseconnect._status(None), ([], []))

@patch("states.suseconnect._status")
    def test__is_registered_default_product(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])
        self.assertTrue(suseconnect._is_registered(product=None, root=None))

@patch("states.suseconnect._status")
    def test__is_registered_product(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])
        self.assertTrue(
            suseconnect._is_registered(product="SLES/15.2/x86_64", root=None)
        )

@patch("states.suseconnect._status")
    def test__is_registered_default_product_unregistered(self, _status):
        _status.return_value = ([], [])
        self.assertFalse(suseconnect._is_registered(product=None, root=None))

@patch("states.suseconnect._status")
    def test__is_registered_product_unregistered(self, _status):
        _status.return_value = ([], [])
        self.assertFalse(
            suseconnect._is_registered(product="SLES/15.2/x86_64", root=None)
        )

@patch("states.suseconnect._status")
    def test__is_registered_other_product_unregistered(self, _status):
        _status.return_value = ([], ["SLES/15.2/x86_64"])
        self.assertFalse(
            suseconnect._is_registered(product="openSUSE/15.2/x86_64", root=None)
        )

@patch("states.suseconnect._status")
    def test_registered_default_product(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])
        result = suseconnect.registered("my_setup", "regcode")
        self.assertEqual(
            result,
            {
                "name": "my_setup",
                "result": True,
                "changes": {},
                "comment": ["Product or module default already registered"],
            },
        )

@patch("states.suseconnect._status")
    def test_registered_named_product(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])
        result = suseconnect.registered("SLES/15.2/x86_64", "regcode")
        self.assertEqual(
            result,
            {
                "name": "SLES/15.2/x86_64",
                "result": True,
                "changes": {},
                "comment": ["Product or module SLES/15.2/x86_64 already registered"],
            },
        )

@patch("states.suseconnect._status")
    def test_registered_product(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])
        result = suseconnect.registered(
            "my_setup", "regcode", product="SLES/15.2/x86_64"
        )
        self.assertEqual(
            result,
            {
                "name": "my_setup",
                "result": True,
                "changes": {},
                "comment": ["Product or module SLES/15.2/x86_64 already registered"],
            },
        )

@patch("states.suseconnect._status")
    def test_registered_test(self, _status):
        _status.return_value = ([], [])

opts_mock = {"test": True}
        with patch.dict(suseconnect.__opts__, opts_mock):
            result = suseconnect.registered("my_setup", "regcode")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": None,
                    "changes": {"default": True},
                    "comment": ["Product or module default would be registered"],
                },
            )

@patch("states.suseconnect._status")
    def test_registered_fail_register(self, _status):
        _status.return_value = ([], [])

opts_mock = {"test": False}
        salt_mock = {
            "suseconnect.register": MagicMock(
                side_effect=CommandExecutionError("some error")
            )
        }
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.registered("my_setup", "regcode")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": False,
                    "changes": {},
                    "comment": ["Error registering default: some error"],
                },
            )

@patch("states.suseconnect._status")
    def test_registered_fail_register_end(self, _status):
        _status.return_value = ([], [])

opts_mock = {"test": False}
        salt_mock = {"suseconnect.register": MagicMock()}
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.registered("my_setup", "regcode")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": False,
                    "changes": {"default": True},
                    "comment": ["Product or module default failed to register"],
                },
            )

@patch("states.suseconnect._status")
    def test_registered_succeed_register(self, _status):
        _status.side_effect = [
            ([], []),
            (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"]),
        ]

opts_mock = {"test": False}
        salt_mock = {"suseconnect.register": MagicMock()}
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.registered("my_setup", "regcode")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": True,
                    "changes": {"default": True},
                    "comment": ["Product or module default registered"],
                },
            )
            salt_mock["suseconnect.register"].assert_called_with(
                "regcode", product=None, email=None, url=None, root=None
            )

@patch("states.suseconnect._status")
    def test_registered_succeed_register_params(self, _status):
        _status.side_effect = [
            ([], []),
            (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"]),
        ]

opts_mock = {"test": False}
        salt_mock = {"suseconnect.register": MagicMock()}
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.registered(
                "my_setup",
                "regcode",
                product="SLES/15.2/x86_64",
                email="user@example.com",
                url=None,
                root=None,
            )
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": True,
                    "changes": {"SLES/15.2/x86_64": True},
                    "comment": ["Product or module SLES/15.2/x86_64 registered"],
                },
            )
            salt_mock["suseconnect.register"].assert_called_with(
                "regcode",
                product="SLES/15.2/x86_64",
                email="user@example.com",
                url=None,
                root=None,
            )

@patch("states.suseconnect._status")
    def test_deregistered_default_product(self, _status):
        _status.return_value = ([], [])
        result = suseconnect.deregistered("my_setup")
        self.assertEqual(
            result,
            {
                "name": "my_setup",
                "result": True,
                "changes": {},
                "comment": ["Product or module default already deregistered"],
            },
        )

@patch("states.suseconnect._status")
    def test_deregistered_named_product(self, _status):
        _status.return_value = ([], [])
        result = suseconnect.deregistered("SLES/15.2/x86_64")
        self.assertEqual(
            result,
            {
                "name": "SLES/15.2/x86_64",
                "result": True,
                "changes": {},
                "comment": [
                    "Product or module SLES/15.2/x86_64 already deregistered"
                ],
            },
        )

@patch("states.suseconnect._status")
    def test_deregistered_other_named_product(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])
        result = suseconnect.deregistered("openSUSE/15.2/x86_64")
        self.assertEqual(
            result,
            {
                "name": "openSUSE/15.2/x86_64",
                "result": True,
                "changes": {},
                "comment": [
                    "Product or module openSUSE/15.2/x86_64 already deregistered"
                ],
            },
        )

@patch("states.suseconnect._status")
    def test_deregistered_product(self, _status):
        _status.return_value = ([], [])
        result = suseconnect.deregistered("my_setup", product="SLES/15.2/x86_64")
        self.assertEqual(
            result,
            {
                "name": "my_setup",
                "result": True,
                "changes": {},
                "comment": [
                    "Product or module SLES/15.2/x86_64 already deregistered"
                ],
            },
        )

@patch("states.suseconnect._status")
    def test_deregistered_test(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])

opts_mock = {"test": True}
        with patch.dict(suseconnect.__opts__, opts_mock):
            result = suseconnect.deregistered("my_setup")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": None,
                    "changes": {"default": True},
                    "comment": ["Product or module default would be deregistered"],
                },
            )

@patch("states.suseconnect._status")
    def test_deregistered_fail_deregister(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])

opts_mock = {"test": False}
        salt_mock = {
            "suseconnect.deregister": MagicMock(
                side_effect=CommandExecutionError("some error")
            )
        }
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.deregistered("my_setup")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": False,
                    "changes": {},
                    "comment": ["Error deregistering default: some error"],
                },
            )

@patch("states.suseconnect._status")
    def test_deregistered_fail_deregister_end(self, _status):
        _status.return_value = (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"])

opts_mock = {"test": False}
        salt_mock = {"suseconnect.deregister": MagicMock()}
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.deregistered("my_setup")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": False,
                    "changes": {"default": True},
                    "comment": ["Product or module default failed to deregister"],
                },
            )

@patch("states.suseconnect._status")
    def test_deregistered_succeed_deregister(self, _status):
        _status.side_effect = [
            (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"]),
            ([], []),
        ]

opts_mock = {"test": False}
        salt_mock = {"suseconnect.deregister": MagicMock()}
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.deregistered("my_setup")
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": True,
                    "changes": {"default": True},
                    "comment": ["Product or module default deregistered"],
                },
            )
            salt_mock["suseconnect.deregister"].assert_called_with(
                product=None, url=None, root=None
            )

@patch("states.suseconnect._status")
    def test_deregistered_succeed_register_params(self, _status):
        _status.side_effect = [
            (["SLES/15.2/x86_64"], ["SLES/15.2/x86_64"]),
            ([], []),
        ]

opts_mock = {"test": False}
        salt_mock = {"suseconnect.deregister": MagicMock()}
        with patch.dict(suseconnect.__salt__, salt_mock), patch.dict(
            suseconnect.__opts__, opts_mock
        ):
            result = suseconnect.deregistered(
                "my_setup", product="SLES/15.2/x86_64", url=None, root=None
            )
            self.assertEqual(
                result,
                {
                    "name": "my_setup",
                    "result": True,
                    "changes": {"SLES/15.2/x86_64": True},
                    "comment": ["Product or module SLES/15.2/x86_64 deregistered"],
                },
            )
            salt_mock["suseconnect.deregister"].assert_called_with(
                product="SLES/15.2/x86_64", url=None, root=None
            )
0707010000008D000081A40000427000000032000000015F4E04F800003742000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1598948600.9a9eab0/tests/test_suseconnect.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LLC.
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations

import os.path
import unittest
from unittest.mock import patch, MagicMock

from salt.exceptions import CommandExecutionError

from modules import suseconnect

class SUSEConnectTestCase(unittest.TestCase):
    """
    Test cases for salt.modules.suseconnect
    """

def test_register(self):
        """
        Test suseconnect.register without parameters
        """
        result = {"retcode": 0, "stdout": "Successfully registered system"}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.register("regcode"), "Successfully registered system"
            )
            salt_mock["cmd.run_all"].assert_called_with(
                ["SUSEConnect", "--regcode", "regcode"]
            )

def test_register_params(self):
        """
        Test suseconnect.register with parameters
        """
        result = {"retcode": 0, "stdout": "Successfully registered system"}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.register(
                    "regcode",
                    product="sle-ha/15.2/x86_64",
                    email="user@example.com",
                    url="https://scc.suse.com",
                    root="/mnt",
                ),
                "Successfully registered system",
            )
            salt_mock["cmd.run_all"].assert_called_with(
                [
                    "SUSEConnect",
                    "--regcode",
                    "regcode",
                    "--product",
                    "sle-ha/15.2/x86_64",
                    "--email",
                    "user@example.com",
                    "--url",
                    "https://scc.suse.com",
                    "--root",
                    "/mnt",
                ]
            )

def test_register_error(self):
        """
        Test suseconnect.register error
        """
        result = {"retcode": 1, "stdout": "Unknown Registration Code", "stderr": ""}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                suseconnect.register("regcode")

def test_deregister(self):
        """
        Test suseconnect.deregister without parameters
        """
        result = {"retcode": 0, "stdout": "Successfully deregistered system"}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.deregister(), "Successfully deregistered system"
            )
            salt_mock["cmd.run_all"].assert_called_with(
                ["SUSEConnect", "--de-register"]
            )

def test_deregister_params(self):
        """
        Test suseconnect.deregister with parameters
        """
        result = {"retcode": 0, "stdout": "Successfully deregistered system"}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.deregister(
                    product="sle-ha/15.2/x86_64",
                    url="https://scc.suse.com",
                    root="/mnt",
                ),
                "Successfully deregistered system",
            )
            salt_mock["cmd.run_all"].assert_called_with(
                [
                    "SUSEConnect",
                    "--de-register",
                    "--product",
                    "sle-ha/15.2/x86_64",
                    "--url",
                    "https://scc.suse.com",
                    "--root",
                    "/mnt",
                ]
            )

def test_deregister_error(self):
        """
        Test suseconnect.deregister error
        """
        result = {"retcode": 1, "stdout": "Unknown Product", "stderr": ""}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                suseconnect.deregister()

def test_status(self):
        """
        Test suseconnect.status without parameters
        """
        result = {
            "retcode": 0,
            "stdout": '[{"identifier":"SLES","version":"15.2",'
            '"arch":"x86_64","status":"No Registered"}]',
        }
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.status(),
                [
                    {
                        "identifier": "SLES",
                        "version": "15.2",
                        "arch": "x86_64",
                        "status": "No Registered",
                    }
                ],
            )
            salt_mock["cmd.run_all"].assert_called_with(["SUSEConnect", "--status"])

def test_status_params(self):
        """
        Test suseconnect.status with parameters
        """
        result = {
            "retcode": 0,
            "stdout": '[{"identifier":"SLES","version":"15.2",'
            '"arch":"x86_64","status":"No Registered"}]',
        }
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.status(root="/mnt"),
                [
                    {
                        "identifier": "SLES",
                        "version": "15.2",
                        "arch": "x86_64",
                        "status": "No Registered",
                    }
                ],
            )
            salt_mock["cmd.run_all"].assert_called_with(
                ["SUSEConnect", "--status", "--root", "/mnt"]
            )

def test_status_error(self):
        """
        Test suseconnect.status error
        """
        result = {"retcode": 1, "stdout": "Some Error", "stderr": ""}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                suseconnect.status()

def test__parse_list_extensions(self):
        """
        Test suseconnect.status error
        """
        fixture = os.path.join(
            os.path.dirname(__file__), "fixtures/list_extensions.txt"
        )
        with open(fixture) as f:
            self.assertEqual(
                suseconnect._parse_list_extensions(f.read()),
                [
                    "sle-module-basesystem/15.2/x86_64",
                    "sle-module-containers/15.2/x86_64",
                    "sle-module-desktop-applications/15.2/x86_64",
                    "sle-module-development-tools/15.2/x86_64",
                    "sle-we/15.2/x86_64",
                    "sle-module-python2/15.2/x86_64",
                    "sle-module-live-patching/15.2/x86_64",
                    "PackageHub/15.2/x86_64",
                    "sle-module-server-applications/15.2/x86_64",
                    "sle-module-legacy/15.2/x86_64",
                    "sle-module-public-cloud/15.2/x86_64",
                    "sle-ha/15.2/x86_64",
                    "sle-module-web-scripting/15.2/x86_64",
                    "sle-module-transactional-server/15.2/x86_64",
                ],
            )

def test_list_extensions(self):
        """
        Test suseconnect.list_extensions without parameters
        """
        result = {
            "retcode": 0,
            "stdout": "Activate with: SUSEConnect -p sle-ha/15.2/x86_64",
        }
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(suseconnect.list_extensions(), ["sle-ha/15.2/x86_64"])
            salt_mock["cmd.run_all"].assert_called_with(
                ["SUSEConnect", "--list-extensions"]
            )

def test_list_extensions_params(self):
        """
        Test suseconnect.list_extensions with parameters
        """
        result = {
            "retcode": 0,
            "stdout": "Activate with: SUSEConnect -p sle-ha/15.2/x86_64",
        }
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.list_extensions(url="https://scc.suse.com", root="/mnt"),
                ["sle-ha/15.2/x86_64"],
            )
            salt_mock["cmd.run_all"].assert_called_with(
                [
                    "SUSEConnect",
                    "--list-extensions",
                    "--url",
                    "https://scc.suse.com",
                    "--root",
                    "/mnt",
                ]
            )

def test_list_extensions_error(self):
        """
        Test suseconnect.list_extensions error
        """
        result = {
            "retcode": 1,
            "stdout": "To list extensions, you must first register " "the base product",
            "stderr": "",
        }
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                suseconnect.list_extensions()

def test_cleanup(self):
        """
        Test suseconnect.cleanup without parameters
        """
        result = {"retcode": 0, "stdout": "Service has been removed"}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(suseconnect.cleanup(), "Service has been removed")
            salt_mock["cmd.run_all"].assert_called_with(["SUSEConnect", "--cleanup"])

def test_cleanup_params(self):
        """
        Test suseconnect.cleanup with parameters
        """
        result = {"retcode": 0, "stdout": "Service has been removed"}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.cleanup(root="/mnt"), "Service has been removed"
            )
            salt_mock["cmd.run_all"].assert_called_with(
                ["SUSEConnect", "--cleanup", "--root", "/mnt"]
            )

def test_cleanup_error(self):
        """
        Test suseconnect.cleanup error
        """
        result = {"retcode": 1, "stdout": "some error", "stderr": ""}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                suseconnect.cleanup()

def test_rollback(self):
        """
        Test suseconnect.rollback without parameters
        """
        result = {
            "retcode": 0,
            "stdout": "Starting to sync system product activations",
        }
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.rollback(), "Starting to sync system product activations"
            )
            salt_mock["cmd.run_all"].assert_called_with(["SUSEConnect", "--rollback"])

def test_rollback_params(self):
        """
        Test suseconnect.rollback with parameters
        """
        result = {
            "retcode": 0,
            "stdout": "Starting to sync system product activations",
        }
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            self.assertEqual(
                suseconnect.rollback(url="https://scc.suse.com", root="/mnt"),
                "Starting to sync system product activations",
            )
            salt_mock["cmd.run_all"].assert_called_with(
                [
                    "SUSEConnect",
                    "--rollback",
                    "--url",
                    "https://scc.suse.com",
                    "--root",
                    "/mnt",
                ]
            )

def test_rollback_error(self):
        """
        Test suseconnect.rollback error
        """
        result = {"retcode": 1, "stdout": "some error", "stderr": ""}
        salt_mock = {
            "cmd.run_all": MagicMock(return_value=result),
        }
        with patch.dict(suseconnect.__salt__, salt_mock):
            with self.assertRaises(CommandExecutionError):
                suseconnect.rollback()
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!1095 blocks

Places

File yomi-0.0.1+git.1598948600.9a9eab0.obscpio of Package yomi-formula (Revision 39b9b0b7b655558dded23160f9cea67a)

Places