File yomi-0.0.1+git.1565191883.64eabeb.obscpio of Package yomi-formula

Overview Repositories Revisions Requests Users Attributes Meta

File yomi-0.0.1+git.1565191883.64eabeb.obscpio of Package yomi-formula (Revision 5793af4db31ee72c8c552409518cdaf9)

Currently displaying revision 5793af4db31ee72c8c552409518cdaf9 , Show latest

07070100000000000081A40000427000000032000000015D4AEECB00002C5D000000000000000000000000000000000000002A00000000yomi-0.0.1+git.1565191883.64eabeb/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.
07070100000001000081A40000427000000032000000015D4AEECB00005805000000000000000000000000000000000000002C00000000yomi-0.0.1+git.1565191883.64eabeb/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.

# Installation

To execute Yomi we need a modern version of Salt, as we need special
features are only on the
[develop](https://github.com/saltstack/salt/tree/develop) 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.

For openSUSE Tumbleweed I create a [package of
Salt](https://build.opensuse.org/package/show/home:aplanas:branches:systemsmanagement:saltstack:testing/salt)
that contains the last released version and a patch with the missing
code that only lives on the develop branch of the code. This is the
package required to be installed where the salt-minion is executed.

To simplify the test and development of Yomi, I also provide a JeOS
(Tumbleweed) based
[image](https://build.opensuse.org/package/show/home:aplanas:Images/test-image-iso)
that includes this patched package. You can use this ISO to boot the node.

## Image boot parameters

With this image we can set the minion ID of the salt-minion and the
master address where the minion will connect, via boot parameters.

By default the minion will try to connect to a master that have the
name `master`. We can change it via the boot parameter `master`. For
example `master=10.0.2.2` will make the minion to search the master in
the address `10.0.2.2`.

The rules for the minion ID are a bit more complicated. Salt, by
default, set the minion ID equal to the IP of the node is none 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 hostname of the system, if is different from localhost.
- The MAC address of the first interface of the system.

## Installing salt-master

You can read the [official
documentation](https://docs.saltstack.com/en/latest/topics/installation/index.html)
about how to install salt-master. For this documentation we are going
to show only the one based on Python virtual environments.

```Bash
python3 -mvenv venv

source venv/bin/activate

pip install --upgrade pip
pip install salt
```

Once the Salt code is living in the venv, we can configure it.

```Bash
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
```

To find more configuration options for salt-master, refer always to
the official documentation. Here we set a very minimal one, we only
specify where to find the salt states, the pillars and from where we
consider the root directory.

## Enabling Autosign

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
line into the master configuration file.

```Bash
echo "autosign_grains_dir: /etc/salt/autosign_grains" >> venv/etc/salt/master
```

The ISO image that I prepared already export some UUIDs generated for
each minion, so we need to list into the master all the possible valid
UUIDs.

```Bash
mkdir -p venv/etc/salt/autosign_grains

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

We can start now the salt-master service manually:

```Bash
salt-master -c venv/etc/salt &
```

## Salt API

Yomi includes a monitoring tool, that read from 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. This
`monitor` tool will connect to the salt-api service to read the status
and send request to Salt, all done via the REST protocol.

We will use CherryPy to serve the requests of Salt API, and we will
also install a basic WebSocket Python library. Supposing that the
virtual environment is activated, we can:

```Bash
pip install cherrypy ws4py
```

As configuration example, we will setup Salt API to use CherryPy,
listen on port 8000, disable SSL and use an eauth based of a plain
text file. Of course this setup is only for testing.

```Bash
mkdir -p venv/etc/salt/master.d

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

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

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

The last line add the user `salt` (with password `linux`) to the user
list file.

After launching salt-master, we can start the Salt API service:

```Bash
salt-api -c venv/etc/salt &
```

With this configuration in place, the monitoring can be done with this
configuration:

```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.

# Pillars in 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).

Pillars 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.

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

Instead of rebooting, reload the new kernel installed in the
  node. If the value is `no` there will be no reboot. This behavior is
  planned to change.

* `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.

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

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

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

If `yes` Yomi will append `console=tty0 console=ttyS0,115200` in the
  Linux command line during the boot. This option is help full when
  the we want to have serial access to console to the new machine.

* `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.

* `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
  kexec: 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`, `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)

* `kernel`: String. Optional.

Line assigned to the `GRUB_CMDLINE_LINUX_DEFAULT` parameter.

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

Value for `GRUB_DISABLE_OS_PROBER` parameter.

Example:

```YAML
bootloader:
  device: /dev/sda1
```

## `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.

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

* `packages`. Array.

List of packages or patters to be installed.

Example:

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

## `salt-minion` section

Install and configure the salt-minion service.

* `configure`. 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.

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

Example:

```YAML
salt-minion:
  configure: 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
```

## `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"
```
07070100000002000041ED0000427000000032000000035D4AEECB00000000000000000000000000000000000000000000002700000000yomi-0.0.1+git.1565191883.64eabeb/docs07070100000003000081A40000427000000032000000015D4AEECB00001565000000000000000000000000000000000000004300000000yomi-0.0.1+git.1565191883.64eabeb/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
```
07070100000004000081A40000427000000032000000015D4AEECB00001043000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1565191883.64eabeb/docs/appendix-yomi-image.md# Appendix: Notes about the Yomi live image

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 mechanism. 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
[OBS](https://build.opensuse.org/package/show/home:aplanas:Images/openSUSE-Tumbleweed-JeOS). This
is an JeOS based image build from openSUSE Tumbleweed
repositories. Also contains a version of `salt-minion` with all the
code that is under review in the SaltStack project, that is required
to run all the states required by Yomi.

The image is configured to simplify the discovery and integration of
systems booted from it. For example, the image is configured to take
advantage of the auto-sign feature of SaltStack, among others details
like indicating the master ID from the boot command line.

## Autosign via UUID

The Yomi image that contains `salt-minion` have already some grains
that publish some UUIDs from a restricted list. We can use this
information from the `salt-master` to recognize nodes that are ready
to be installed, and avoid the acceptance of the key in the master.

During the creation of the image in OBS, a random UUID using a DNS
name-space is generated and assigned to the `salt-minion` service that
will be executed after the boot process.

The `salt-master` in your network needs to be configured to recognize
and accept those UUIDs. If we have the `yomi-formula` package
installed, we can enable this feature copying the configuration
snipped that comes in the package and restarting the server:

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

If we want to enable this service manually, we will first to generate
the list of 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
```

Now we need to enable this option in master configuration, and restart
the service:

```bash
echo "autosign_grains_dir: /etc/salt/autosign_grains" > /etc/salt/master.d/autosign.conf
systemctl restart salt-master.service
```

With this feature enabled we can skip the `salt-key -A` for nodes
booted from the Yomi image.

## Finding the master node

The `salt-minion` configuration in the Yomi image will search the
`salt-master` system under the `master` name. Is expected that the
local DNS service will resolve the `master` 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`.

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 small service that read the boot command line, will use by default
the host name as the minion ID if no parameter is set. This will make
very easy to set the ID via DHCP. But if there is not host name (other
than localhost), the MAC address of the first interface will be used.
07070100000005000041ED0000427000000032000000035D4AEECB00000000000000000000000000000000000000000000003000000000yomi-0.0.1+git.1565191883.64eabeb/docs/examples07070100000006000041ED0000427000000032000000045D4AEECB00000000000000000000000000000000000000000000003600000000yomi-0.0.1+git.1565191883.64eabeb/docs/examples/kubic07070100000007000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1565191883.64eabeb/docs/examples/kubic/kubic07070100000008000081A40000427000000032000000015D4AEECB000005B1000000000000000000000000000000000000004E00000000yomi-0.0.1+git.1565191883.64eabeb/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
0707010000000A000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1565191883.64eabeb/docs/examples/kubic/orch0707010000000B000081A40000427000000032000000015D4AEECB0000034F000000000000000000000000000000000000004500000000yomi-0.0.1+git.1565191883.64eabeb/docs/examples/kubic/orch/kubic.slssynchronize_all:
  salt.function:
    - name: saltutil.sync_all
    - tgt: '*'

install_microos:
  salt.state:
    - sls:
      - yomi.installer
    - 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
0707010000000C000081A40000427000000032000000015D4AEECB00002057000000000000000000000000000000000000004500000000yomi-0.0.1+git.1565191883.64eabeb/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
[appendix-yomi-image.md](appendix-yomi-image.md) document.

Download the image and optionally configure the `salt-master` to
enable the auto-sign feature via UUID, as described in the previous
document.

In the `master` node we will need to install the `yomi-formula`
package. As today this package is not living in Factory, so we need to
add the repository manually.

```bash
zypper ar -g -f \
  https://download.opensuse.org/repositories/home:/aplanas/openSUSE_Factory/ \
  yomi-formula
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.

### Setting the pillars

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.

As today the `/srv` directory is part of the non-writable subvolume in
MicroOS (the next MicroOS version will fix that), so for this example
we need to add a new place where pillars are living:

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

This will add a new configuration file that will make
`/usr/share/yomi/pillar` available for Salt, that is where the example
pillars are installed.

As today `/usr/share/yomi/pillar/` and `/srv/pillar/` are read-only
volumes, if we want to tailor the pillars we will need to copy the
examples in a different way and configure accordingly the master. For
example:

```bash
mkdir -p /tmp/pillar
cp -a /usr/share/yomi/pillar/* /tmp/pillar/
cat <<EOF > /etc/salt/master.d/pillar.conf
pillar_roots:
  base:
    - /tmp/pillar
    - /srv/pillar
EOF
systemctl restart salt-master.service
```

Once `/srv/pillar` is writable in MicroOS, the best solution will be
copying the pillar content from `yomi-formula` to `/srv/pillar`
directly, and forget about the `pillar.conf` overlay.

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.installer
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
```

### Cleaning the disk

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 worker2 partition.list /dev/sda

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

# Remove all the partitions and the filesystem information
salt worker2 devides.wipe /dev/sda
```

### Launching Yomi

Finally, to install MicroOS into the new worker, we need to apply the
high-state into the node:

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

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

```bash
kubicctl node add worker2
```

### Salt-API and monitoring the installation

We can use the `monitor` CLI tool to inspect the installation of the
nodes. This tool analyze the event stream, and this require the
configuration of `salt-api`:

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

Use this configuration as an example to understand Yomi's features, as
is not using SSL, and the default user and password is located in
`/usr/share/yomi/user-list.txt` in plain text.

Change in the pillars the `config` section, so you have this:

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

Now for each state in Yomi, a two events will be launched. One will
indicate the moment that the state is starting to run, and other will
signalize the success or fail of the event. We can monitor them with:

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

monitor -r -y
```
0707010000000D000081A40000427000000032000000015D4AEECB0000216B000000000000000000000000000000000000005000000000yomi-0.0.1+git.1565191883.64eabeb/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.

## 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 without using `libvirt`. We will require `QEMU`, `socat`
and `dnsmasq`. If you want to use a different mechanism, like using
`libvirt`, `virtualbox` or `vagrant`, you will need to make some
adjustments in the process.

The general process will be to install a local `salt-master`, that
will be used to install MicroOS in two VMs. We will use a salt
orchestrator 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

We can use the official openSUSE Salt package to control the minions,
but we need in the minions the patched version of Salt. The current
images of JeOS that can be used with Yomi already contains this
patched version for the minion.

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

We can now clone the [Yomi](https://github.com/openSUSE/yomi) git
repository, or install the package in our system.

```bash
sudo zypper ar -g -f \
  https://download.opensuse.org/repositories/home:/aplanas/openSUSE_Factory/ \
  yomi-formula
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
```

### Creating the local network

First, 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
```

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,cplane \
             --dhcp-host=00:00:00:22:22:22,10.0.3.102,worker \
             --host-record=master,10.0.2.2
```

The hostnames `cplane` and `worker` and `worker2` will be assigned
based on the MAC address, and `cplane` name will be always resolved to
10.0.3.101, the VM that will be assigned to allocate the control plane
services of the cluster.

The `master` record is to be sure that this name resolves to the IP
that QEMU assign to the host node, that is the one that contains the
`salt-master` service.

### Orchestrating the Kubic installation

Now we can launch two nodes. One will be used for the control plane,
and will be assigned with the `cplane` hostname, and the other will be
the single worker.

First we will need to download a JeOS image with a version of
`salt-minion` that contains some patches. The image is placed in this
[repository](https://download.opensuse.org/repositories/home:/aplanas:/Images/images/iso/),
you can `wget` it, but if you have `osc` installed you can also
download it directly:

```bash
osc getbinaries home:aplanas:Images openSUSE-Tumbleweed-JeOS:Live images x86_64
mv binaries/*.iso .
rm -fr binaries
```

In the same directory where our Yomi ISO image is living, we can
launch both nodes. But first, to make the command a bit more compact,
we will 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 the nodes:

```bash
NODES=2
for i in $(seq $NODES); do
  # Remove the node fingerprint if needed
  ssh-keygen -R [localhost]:${i}0022 -f ~/.ssh/known_hosts
  # Create the QCOW2 image if needed
  [ -e hda-node${i}.qcow2 ] || qemu-img create -f qcow2 hda-node${i}.qcow2 50G
  cp -af ovmf-x86_64-vars.bin ovmf-x86_64-vars-${i}.bin
  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:${i}${i}:${i}${i}:${i}${i} \
    -netdev user,id=net0,hostfwd=tcp::${i}0022-:22 \
    -device virtio-net-pci,netdev=net0,mac=10:00:00:${i}${i}:${i}${i}:${i}${i} \
    -cdrom openSUSE-Tumbleweed*.iso \
    -hda hda-node${i}.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-${i}.bin \
    -smp 2 \
    -boot d &
done
```

You can see if the nodes are answering request with this test:

```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`)

For now we need to change a bit the pillar information. `salt-minion`
will be installed in both nodes, and will automatically reconnect to
the master after the first boot. We will need to be sure that the
version of `salt-minion` that is installed is the patched one, so we
will add one extra repository in the pillars.

Edit the pillar/installer.sls file and check that the `repositories`
section have this content:

```yaml
repositories:
{% if mode == 'microos' %}
    repo-salt-fix: "https://download.opensuse.org/repositories/home:/aplanas:/branches:/systemsmanagement:/saltstack/testing/openSUSE_Tumbleweed/"
{% endif %}
    repo-oss: "http://download.opensuse.org/tumbleweed/repo/oss"
```

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 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.
0707010000000E000081ED0000427000000032000000015D4AEECB00003A6B000000000000000000000000000000000000002A00000000yomi-0.0.1+git.1565191883.64eabeb/monitor#!/usr/bin/python3

# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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 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)
0707010000000F000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000002900000000yomi-0.0.1+git.1565191883.64eabeb/pillar070701000000100000A1FF0000427000000032000000015D4193F400000014000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1565191883.64eabeb/pillar/_storage.sls.kubic_storage.sls.microos07070100000011000081A40000427000000032000000015D4AEECB00000956000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1565191883.64eabeb/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
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
{% endif %}
{% if home_filesystem %}
  /dev/system/home:
    filesystem: {{ home_filesystem }}
    mountpoint: /home
{% endif %}

bootloader:
  device: /dev/{{ device_type }}a
07070100000012000081A40000427000000032000000015D4AEECB000008CA000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1565191883.64eabeb/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: tmp
        - path: home
        - path: opt
        - path: srv
        - path: boot/writable
        - path: usr/local
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
{% 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
07070100000013000081A40000427000000032000000015D4AEECB00000AD9000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1565191883.64eabeb/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
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
{% 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
07070100000014000081A40000427000000032000000015D4AEECB00000914000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1565191883.64eabeb/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
        - path: boot/grub2/i386-pc
        - path: boot/grub2/x86_64-efi
{% 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
07070100000015000081A40000427000000032000000015D4AEECB00000A58000000000000000000000000000000000000003700000000yomi-0.0.1+git.1565191883.64eabeb/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'}
#
# 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 = 'kubic' %}

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

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

software:
  config:
    minimal: {{ 'yes' if mode in ('microos', 'kubic') else 'no' }}
  repositories:
    repo-oss: "http://download.opensuse.org/tumbleweed/repo/oss"
  packages:
{% if mode == 'microos' %}
    - pattern:microos_base
    - pattern:microos_defaults
    - pattern:microos_hardware
    - pattern:microos_apparmor
{% elif mode == 'kubic' %}
    - pattern:microos_base
    - pattern:microos_defaults
    - pattern:microos_hardware
    - pattern:microos_apparmor
    - pattern:kubic_worker
{% else %}
    - patterns-base-base
    - kernel-default
{% endif %}

salt-minion:
  configure: yes

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

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"
07070100000016000081A40000427000000032000000015D4AEECB0000001D000000000000000000000000000000000000003100000000yomi-0.0.1+git.1565191883.64eabeb/pillar/top.slsbase:
  '*':
    - installer
07070100000017000041ED0000427000000032000000075D4AEECB00000000000000000000000000000000000000000000002700000000yomi-0.0.1+git.1565191883.64eabeb/salt07070100000018000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000002F00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_grains07070100000019000081A40000427000000032000000015D4AEECB0000056C000000000000000000000000000000000000003600000000yomi-0.0.1+git.1565191883.64eabeb/salt/_grains/efi.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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
0707010000001A000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003000000000yomi-0.0.1+git.1565191883.64eabeb/salt/_modules0707010000001B000081A40000427000000032000000015D4AEECB00001271000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_modules/devices.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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)
    return True
0707010000001C000081A40000427000000032000000015D4AEECB0000071E000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_modules/filters.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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)
0707010000001D000081A40000427000000032000000015D4AEECB00002BB5000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_modules/partmod.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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
0707010000001E000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000002F00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_states0707010000001F000081A40000427000000032000000015D4AEECB00000FAF000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_states/formatted.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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=u'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': [],
    }
    # Check if fstype is linux-swap
    # check if partition is type 82
    # check if is already formated
    # if forced, format, but maybe check if swapon over the partition

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
07070100000020000081A40000427000000032000000015D4AEECB00005D35000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_states/partitioned.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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 = {
        'msdos': 'dos',
        }.get(label, label)
    res = __salt__['cmd.run'](['fdisk', '-l', device])
    return 'disklabel type: {}'.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
07070100000021000081A40000427000000032000000015D4AEECB00002867000000000000000000000000000000000000004200000000yomi-0.0.1+git.1565191883.64eabeb/salt/_states/snapper_install.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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['device']

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
07070100000022000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000002E00000000yomi-0.0.1+git.1565191883.64eabeb/salt/_utils07070100000023000081A40000427000000032000000015D4AEECB0000066C000000000000000000000000000000000000003600000000yomi-0.0.1+git.1565191883.64eabeb/salt/_utils/disk.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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))
07070100000024000081A40000427000000032000000015D4AEECB000041AB000000000000000000000000000000000000003400000000yomi-0.0.1+git.1565191883.64eabeb/salt/_utils/lp.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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])
07070100000025000081A40000427000000032000000015D4AEECB000006EA000000000000000000000000000000000000003200000000yomi-0.0.1+git.1565191883.64eabeb/salt/macros.yml# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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 %}

07070100000026000081A40000427000000032000000015D4AEECB00000022000000000000000000000000000000000000002F00000000yomi-0.0.1+git.1565191883.64eabeb/salt/top.slsbase:
  '*':
    - yomi.installer
07070100000027000041ED0000427000000032000000065D4AEECB00000000000000000000000000000000000000000000002C00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi07070100000028000081A40000427000000032000000015D4AEECB0000016C000000000000000000000000000000000000004000000000yomi-0.0.1+git.1565191883.64eabeb/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
07070100000029000081A40000427000000032000000015D4AEECB0000032C000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/_firstboot.sls{% import 'macros.yml' as macros %}

{% set config = pillar['config'] %}

{{ macros.log('module', 'systemd_firstboot') }}
systemd_firstboot:
  module.run:
    - 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 %}
      - root: /mnt
    - creates:
        - /mnt/etc/hostname
        - /mnt/etc/locale.conf
        - /mnt/etc/localtime
        - /mnt/etc/machine-id
        - /mnt/etc/vconsole.conf
0707010000002A000081A40000427000000032000000015D4AEECB000004CD000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/_software.sls{% import 'macros.yml' as macros %}

{% set software = pillar['software'] %}
{% set software_config = software.get('config', {}) %}

{% if software_config.get('minimal', False) %}
{{ 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 %}

{% for name, repo in software.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 %}

{{ macros.log('pkg', 'install_packages') }}
install_packages:
  pkg.installed:
    - pkgs: {{ software.packages }}
    - no_recommends: yes
    - includes: [pattern]
    - root: /mnt

{% if software_config.get('minimal', False) %}
{{ 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 %}
0707010000002B000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003700000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/bootloader0707010000002C000081A40000427000000032000000015D4AEECB0000033E000000000000000000000000000000000000004900000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/bootloader/grub2_install.sls{% import 'macros.yml' as macros %}

{% set bootloader = pillar['bootloader'] %}
{% set is_uefi = grains['efi'] %}
{% set is_secure_boot = grains['efi-secure-boot'] %}

{{ macros.log('cmd', 'grub2_install') }}
grub2_install:
  cmd.run:
{% if is_uefi %}
  {% if is_secure_boot %}
    - name: shim-install --config-file=/boot/grub2/grub.cfg
  {% else %}
    - name: grub2-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=GRUB
  {% endif %}
    - creates: /mnt/boot/efi/EFI/GRUB
{% else %}
    - name: grub2-install --force {{ bootloader.device }}
    - unless: dd bs=512 count=1 if={{ bootloader.device }} 2>/dev/null | grep -q 'GRUB'
{% endif %}
{% if 'lvm' in pillar %}
    - binds: [/run]
    - env:
      - LVM_SUPPRESS_FD_WARNINGS: 1
{% endif %}
    - root: /mnt
    - require:
      - cmd: grub2_mkconfig
0707010000002D000081A40000427000000032000000015D4AEECB000007CB000000000000000000000000000000000000004A00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/bootloader/grub2_mkconfig.sls{% import 'macros.yml' as macros %}

{% set config = pillar['config'] %}
{% set bootloader = pillar['bootloader'] %}
{% set is_uefi = grains['efi'] %}

{% if config.get('snapper', False) %}
include:
  {% if config.get('snapper', False) %}
  - ..storage.snapper.grub2_mkconfig
  {% endif %}
{% endif %}

{% if is_uefi %}
{{ macros.log('file', 'config_grub2_efi') }}
config_grub2_efi:
  file.append:
    - name: /mnt/etc/default/grub
    - text: GRUB_USE_LINUXEFI="true"
{% endif %}

{% if config.get('grub2_theme', False) %}
{{ macros.log('file', 'config_grub2_theme') }}
config_grub2_theme:
  file.append:
    - name: /mnt/etc/default/grub
    - text:
      - GRUB_TERMINAL="gfxterm"
      - GRUB_GFXMODE="auto"
      - GRUB_BACKGROUND=
      # - GRUB_THEME="/boot/grub2/themes/openSUSE/theme.txt"
{% endif %}

{% set kernel = 'splash=silent quiet' %}
{% if config.get('grub2_console', False) %}
  {% set kernel = kernel ~ ' console=tty0 console=ttyS0,115200' %}
{% endif %}
{% if bootloader.get('kernel', False) %}
  {% set kernel = kernel ~ ' ' ~ bootloader['kernel'] %}
{% endif %}
{{ macros.log('file', 'config_grub2_resume') }}
config_grub2_resume:
  file.append:
    - name: /mnt/etc/default/grub
    - text:
      - GRUB_TIMEOUT=8
{% if 'lvm' not in pillar %}
      - GRUB_DEFAULT="saved"
      # - GRUB_SAVEDEFAULT="true"
{% endif %}
      - GRUB_CMDLINE_LINUX_DEFAULT="{{ kernel }}"
      - GRUB_DISABLE_OS_PROBER="{{ true if bootloader.get('disable_os_prober', False) else false }}"

{{ 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 'lvm' in pillar %}
    - binds: [/run]
{% endif %}
    - watch:
      - file: /mnt/etc/default/grub
0707010000002E000081A40000427000000032000000015D4AEECB00000063000000000000000000000000000000000000004000000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/bootloader/init.sls{% set config = pillar['config'] %}

include:
  - .mkinitrd
  - .grub2_mkconfig
  - .grub2_install
0707010000002F000081A40000427000000032000000015D4AEECB000000A8000000000000000000000000000000000000004400000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/bootloader/mkinitrd.sls{% import 'macros.yml' as macros %}

{{ macros.log('cmd', 'mkinitrd') }}
mkinitrd:
  cmd.run:
    - name: mkinitrd -d /mnt -b /mnt/boot
    - creates: /mnt/boot/initrd
07070100000030000081A40000427000000032000000015D4AEECB00000218000000000000000000000000000000000000004400000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/bootloader/software.sls{% import 'macros.yml' as macros %}

{% set config = pillar['config'] %}
{% set is_uefi = grains['efi'] %}
{% set is_secure_boot = grains['efi-secure-boot'] %}

{{ macros.log('pkg', 'install_grub2') }}
install_grub2:
  pkg.installed:
    - pkgs:
      - grub2
{% if config.get('grub2_theme', False) %}
      - grub2-branding-openSUSE
{% endif %}
{% if is_uefi %}
      - grub2-x86_64-efi
  {% if is_secure_boot %}
      - shim
  {% endif %}
{% endif %}
    - no_recommends: yes
    - root: /mnt
    - require:
      - mount: mount_/mnt
07070100000031000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003300000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/chroot07070100000032000081A40000427000000032000000015D4AEECB00000131000000000000000000000000000000000000004400000000yomi-0.0.1+git.1565191883.64eabeb/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 ]"
07070100000033000081A40000427000000032000000015D4AEECB000001DC000000000000000000000000000000000000004000000000yomi-0.0.1+git.1565191883.64eabeb/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
    - root: /mnt
    - require:
      - mount: mount_/mnt
07070100000034000081A40000427000000032000000015D4AEECB00000134000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/installer.sls{% set config = pillar['config'] %}

# TODO(aplanas): Think about a better guard
{% if not salt.file.file_exists('/etc/yomi-installed') %}
include:
  - .storage
  - .software
  - .users
  - .bootloader
  - .services
  - .post_install
  {% if config.get('kexec', True) %}
  - .kexec
  {% endif %}
{% endif %}
07070100000035000081A40000427000000032000000015D4AEECB00000262000000000000000000000000000000000000003600000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/kexec.sls{% import 'macros.yml' as macros %}

{{ 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
07070100000036000081A40000427000000032000000015D4AEECB00000061000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/post_install.slsinclude:
  - .chroot.post_install
  - ._firstboot
  - ._default_target
  - .storage.post_install
07070100000037000041ED0000427000000032000000035D4AEECB00000000000000000000000000000000000000000000003500000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/services07070100000038000081A40000427000000032000000015D4AEECB00000322000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/services/init.sls{% import 'macros.yml' as macros %}

{% set services = pillar.get('services', {}) %}

include:
  - .network
{% if 'salt-minion' in pillar %}
  - .salt-minion
{% endif %}

{% for service in services.get('enabled', []) %}
{{ macros.log('module', 'enable_service_' ~ service) }}
enable_service_{{ service }}:
  module.run:
    - service.enable:
      - name: {{ service }}
      - root: /mnt
    - 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:
    - service.disable:
      - name: {{ service }}
      - root: /mnt
    - onlyif: systemctl --root=/mnt --quiet is-enabled {{ service }} 2> /dev/null
{% endfor %}
07070100000039000081A40000427000000032000000015D4AEECB000002FB000000000000000000000000000000000000004100000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/services/network.sls{% import 'macros.yml' as macros %}

{% set interfaces = salt.network.interfaces() | select('!=', 'lo') %}

{% for interface in interfaces %}
{{ 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'
{% endfor %}

{{ 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"
0707010000003A000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000004100000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/services/salt-minion0707010000003B000081A40000427000000032000000015D4AEECB00000198000000000000000000000000000000000000004A00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/services/salt-minion/init.sls{% import 'macros.yml' as macros %}

{% set salt_minion = pillar.get('salt-minion', {}) %}

{% if salt_minion.get('configure', False) %}
{{ macros.log('module', 'create_salt-minion') }}
create_salt-minion:
  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 ]"
{% endif %}
0707010000003C000081A40000427000000032000000015D4AEECB000000E5000000000000000000000000000000000000004E00000000yomi-0.0.1+git.1565191883.64eabeb/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
0707010000003D000081A40000427000000032000000015D4AEECB000000A6000000000000000000000000000000000000004200000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/services/software.sls{% set config = pillar['config'] %}

{% if 'salt-minion' in pillar %}
include:
  {% if 'salt-minion' in pillar %}
  - .salt-minion.software
  {% endif %}
{% endif %}
0707010000003E000081A40000427000000032000000015D4AEECB00000073000000000000000000000000000000000000003900000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/software.slsinclude:
  - ._software
  - .storage.software
  - .bootloader.software
  - .services.software
  - .chroot.software
0707010000003F000041ED0000427000000032000000075D4AEECB00000000000000000000000000000000000000000000003400000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage07070100000040000081A40000427000000032000000015D4AEECB0000045F000000000000000000000000000000000000004300000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000041000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/btrfs07070100000042000081A40000427000000032000000015D4AEECB000005DD000000000000000000000000000000000000004400000000yomi-0.0.1+git.1565191883.64eabeb/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
07070100000043000081A40000427000000032000000015D4AEECB0000034F000000000000000000000000000000000000004400000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000044000081A40000427000000032000000015D4AEECB000001C4000000000000000000000000000000000000004B00000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000045000081A40000427000000032000000015D4AEECB0000042B000000000000000000000000000000000000004800000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000046000081A40000427000000032000000015D4AEECB00000228000000000000000000000000000000000000004500000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000048000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003B00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/device07070100000049000081A40000427000000032000000015D4AEECB0000046F000000000000000000000000000000000000004500000000yomi-0.0.1+git.1565191883.64eabeb/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
0707010000004A000081A40000427000000032000000015D4AEECB0000033A000000000000000000000000000000000000004500000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
0707010000004B000081A40000427000000032000000015D4AEECB000002CE000000000000000000000000000000000000004600000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
0707010000004C000081A40000427000000032000000015D4AEECB000001A5000000000000000000000000000000000000003F00000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
0707010000004D000081A40000427000000032000000015D4AEECB000000A8000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/fstab.sls{% set config = pillar['config'] %}

include:
  - .create_fstab
  - .device.fstab
  - .btrfs.fstab
{% if config.get('snapper', False) %}
  - .snapper.fstab
{% endif %}
0707010000004E000081A40000427000000032000000015D4AEECB00000061000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/init.slsinclude:
  - .partition
  - .raid
  - .volumes
  - .format
  - .subvolumes
  - .fstab
  - .mount
0707010000004F000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003800000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/lvm07070100000050000081A40000427000000032000000015D4AEECB000000D0000000000000000000000000000000000000004500000000yomi-0.0.1+git.1565191883.64eabeb/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
07070100000051000081A40000427000000032000000015D4AEECB0000055B000000000000000000000000000000000000004300000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000052000081A40000427000000032000000015D4AEECB00000049000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/mark.slscreate_yomi_installed:
  file.touch:
    - name: /mnt/etc/yomi-installed
07070100000053000081A40000427000000032000000015D4AEECB00000096000000000000000000000000000000000000003E00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/mount.sls{% set config = pillar['config'] %}

include:
  - .device.mount
  - .btrfs.mount
{% if config.get('snapper', False) %}
  - .snapper.mount
{% endif %}
07070100000054000081A40000427000000032000000015D4AEECB0000004B000000000000000000000000000000000000004200000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/partition.sls{% set filter=salt.filters.is_not_raid %}
{% include "./_partition.sls" %}
07070100000055000081A40000427000000032000000015D4AEECB000000DB000000000000000000000000000000000000004500000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/post_install.sls{% set config = pillar['config'] %}

include:
{% if config.get('snapper', False) %}
  - .snapper.post_install
{% endif %}
  - .mark
  - .btrfs.post_install
{% if not config.get('kexec', True) %}
  - .umount
{% endif %}
07070100000056000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003900000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/raid07070100000057000081A40000427000000032000000015D4AEECB00000023000000000000000000000000000000000000004200000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/raid/init.slsinclude:
  - .mdadm
  - .partition
07070100000058000081A40000427000000032000000015D4AEECB000001AD000000000000000000000000000000000000004300000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000059000081A40000427000000032000000015D4AEECB00000048000000000000000000000000000000000000004700000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/raid/partition.sls{% set filter=salt.filters.is_raid %}
{% include "../_partition.sls" %}
0707010000005A000081A40000427000000032000000015D4AEECB000000E8000000000000000000000000000000000000004600000000yomi-0.0.1+git.1565191883.64eabeb/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
0707010000005B000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000003C00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/snapper0707010000005C000081A40000427000000032000000015D4AEECB00000516000000000000000000000000000000000000004600000000yomi-0.0.1+git.1565191883.64eabeb/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
0707010000005D000081A40000427000000032000000015D4AEECB000000CC000000000000000000000000000000000000004F00000000yomi-0.0.1+git.1565191883.64eabeb/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"
0707010000005E000081A40000427000000032000000015D4AEECB0000028B000000000000000000000000000000000000004600000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
0707010000005F000081A40000427000000032000000015D4AEECB00000270000000000000000000000000000000000000004D00000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000060000081A40000427000000032000000015D4AEECB0000012D000000000000000000000000000000000000004900000000yomi-0.0.1+git.1565191883.64eabeb/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
07070100000061000081A40000427000000032000000015D4AEECB0000026E000000000000000000000000000000000000004A00000000yomi-0.0.1+git.1565191883.64eabeb/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 %}
07070100000062000081A40000427000000032000000015D4AEECB0000011D000000000000000000000000000000000000004700000000yomi-0.0.1+git.1565191883.64eabeb/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 }}
07070100000063000081A40000427000000032000000015D4AEECB0000014A000000000000000000000000000000000000004100000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/software.sls{% set config = pillar['config'] %}

{% if 'raid' in pillar or 'lvm' in pillar or config.get('snapper', False) %}
include:
  {% if 'raid' in pillar %}
  - .raid.software
  {% endif %}
  {% if 'lvm' in pillar %}
  - .lvm.software
  {% endif %}
  {% if config.get('snapper', False) %}
  - .snapper.software
  {% endif %}
{% endif %}07070100000064000081A40000427000000032000000015D4AEECB0000008C000000000000000000000000000000000000004300000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/subvolumes.sls{% set config = pillar['config'] %}

include:
  - .btrfs.subvolume
{% if config.get('snapper', False) %}
  - .snapper.subvolume
{% endif %}
07070100000065000081A40000427000000032000000015D4AEECB00000099000000000000000000000000000000000000003F00000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/umount.sls{% set config = pillar['config'] %}

include:
{% if config.get('snapper', False) %}
  - .snapper.umount
{% endif %}
  - .btrfs.umount
  - .device.umount
07070100000066000081A40000427000000032000000015D4AEECB00000019000000000000000000000000000000000000004000000000yomi-0.0.1+git.1565191883.64eabeb/salt/yomi/storage/volumes.slsinclude:
  - .lvm.volume
07070100000067000081A40000427000000032000000015D4AEECB000004F1000000000000000000000000000000000000003600000000yomi-0.0.1+git.1565191883.64eabeb/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) }}
set_password_user_{{ user.username }}:
  module.run:
    - shadow.set_password:
      - name: {{ user.username }}
      - password: {{ user.password }}
      - use_usermod: yes
      - root: /mnt
    - 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 %}
07070100000068000041ED0000427000000032000000035D4AEECB00000000000000000000000000000000000000000000002800000000yomi-0.0.1+git.1565191883.64eabeb/tests07070100000069000081ED0000427000000032000000015D4AEECB000006B7000000000000000000000000000000000000003500000000yomi-0.0.1+git.1565191883.64eabeb/tests/run_tests.sh#! /bin/bash

#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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

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
0707010000006A000041ED0000427000000032000000025D4AEECB00000000000000000000000000000000000000000000002D00000000yomi-0.0.1+git.1565191883.64eabeb/tests/unit0707010000006B000081A40000427000000032000000015D4AEECB00000000000000000000000000000000000000000000003900000000yomi-0.0.1+git.1565191883.64eabeb/tests/unit/__init__.py0707010000006C000081A40000427000000032000000015D4AEECB00000B4F000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1565191883.64eabeb/tests/unit/test_devices.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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 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'])
0707010000006D000081A40000427000000032000000015D4AEECB0000054B000000000000000000000000000000000000003A00000000yomi-0.0.1+git.1565191883.64eabeb/tests/unit/test_disk.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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')
0707010000006E000081A40000427000000032000000015D4AEECB000055E2000000000000000000000000000000000000003800000000yomi-0.0.1+git.1565191883.64eabeb/tests/unit/test_lp.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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()
0707010000006F000081A40000427000000032000000015D4AEECB00003E45000000000000000000000000000000000000004100000000yomi-0.0.1+git.1565191883.64eabeb/tests/unit/test_partitioned.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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 _: 'Disklabel type: dos'
        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 _: 'Disklabel type: dos'
        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 _: 'Disklabel type: dos',
        )
        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')

_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', '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_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()
07070100000070000081A40000427000000032000000015D4AEECB00006D7C000000000000000000000000000000000000003D00000000yomi-0.0.1+git.1565191883.64eabeb/tests/unit/test_partmod.py# -*- coding: utf-8 -*-
#
# Author: Alberto Planas <aplanas@suse.com>
#
# Copyright 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# 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()
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!565 blocks

Places

File yomi-0.0.1+git.1565191883.64eabeb.obscpio of Package yomi-formula (Revision 5793af4db31ee72c8c552409518cdaf9)

Places