-
Notifications
You must be signed in to change notification settings - Fork 45
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Upgrading to 2.7 does not re-enable loop device provisioning #2982
Labels
complexity:easy
Something that requires less than a day to fix
kind:bug
Something isn't working
release:blocker
An issue that blocks a release until resolved
topic:lifecycle
Issues related to upgrade or downgrade of MetalK8s
topic:salt
Everything related to SaltStack in our product
topic:storage
Issues related to storage
Milestone
Comments
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 15, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 16, 2020
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 16, 2020
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 16, 2020
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 16, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 16, 2020
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 17, 2020
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Dec 17, 2020
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Dec 17, 2020
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Jan 7, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Jan 8, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 11, 2021
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 11, 2021
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Jan 11, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 12, 2021
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 12, 2021
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 12, 2021
This will ensure all loop devices are managed as expected after an upgrade. Note that this means invalid Volumes which were not prepared yet will break upgrade. Fixes: #2982
gdemonet
added a commit
that referenced
this issue
Jan 12, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 12, 2021
This will simplify the introduction of other states depending on `.installed`, into which we move the systemd unit template and cleanup script creation. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 12, 2021
Since the management of loop devices changed between 2.6 and 2.7 (introduction of systemd units for this purpose), we want to ensure there will not be duplicated devices pointing to the same sparse file. To do this, we introduce a "cleanup" formula, which can operate in two modes, 'upgrade' and 'downgrade' (controlled via pillar). For upgrade, we manage this cleanup in the `deploy_node` orchestrate, during the drain. For downgrade, we cannot change the `deploy_node` orchestrate, so we manually drain and cleanup from the `downgrade` orchestrate. See: #2982
gdemonet
added a commit
that referenced
this issue
Jan 12, 2021
The `volume_utils` module interacts with a C library, and some values are `c_char_p` which translates to bytes in Python 3 (instead of string in Python 2). This change breaks the blkid probe, which in turns makes the `metalk8s_volumes.is_prepared` execution function always return False. Adding `.decode('ascii')` to the relevant places fixes this issue. See: bddea0b See: #2982
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Labels
complexity:easy
Something that requires less than a day to fix
kind:bug
Something isn't working
release:blocker
An issue that blocks a release until resolved
topic:lifecycle
Issues related to upgrade or downgrade of MetalK8s
topic:salt
Everything related to SaltStack in our product
topic:storage
Issues related to storage
Component: salt, upgrade
What happened:
When implementing a solution for #2726 in #2936, we failed to account for upgrade scenarios, where existing SparseLoopDevice Volumes already provisioned will not have a proper systemd unit created.
Thus, after upgrade, any such Volume will fail to have its device provisioned on node reboot.
What was expected: Seamless upgrade, loop devices still provisioned on node startup.
Steps to reproduce: From a MetalK8s 2.6 cluster with existing SparseLoopDevice Volumes, upgrade to 2.7 and reboot.
Resolution proposal (optional):
metalk8s_volumes
module)The text was updated successfully, but these errors were encountered: