Apply black formatter to dcmanager/db

This commit applies the Black format to the `dcmanager/db`
files to ensure that it adheres to the Black code style guidelines.

Test Plan:
PASS: Success in stx-distcloud-tox-black

Story: 2011149
Task: 50444

Change-Id: Id6b0e2f15ea7c8ee79b3c35b534bf3a27893256b
Signed-off-by: Hugo Brito <hugo.brito@windriver.com>

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/manage.py

@@ -1,5 +1,10 @@
 #!/usr/bin/env python
+# Copyright (c) 2024 Wind River Systems, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
 from migrate.versioning.shell import main
 
-if __name__ == '__main__':
+if __name__ == "__main__":
-    main(debug='False')
+    main(debug="False")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/001_first_version.py

@@ -25,133 +25,138 @@ def upgrade(migrate_engine):
     meta.bind = migrate_engine
 
     subclouds = sqlalchemy.Table(
-        'subclouds', meta,
+        "subclouds",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True, nullable=False),
+        sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True, nullable=False),
-        sqlalchemy.Column('name', sqlalchemy.String(255), unique=True),
+        sqlalchemy.Column("name", sqlalchemy.String(255), unique=True),
-        sqlalchemy.Column('description', sqlalchemy.String(255)),
+        sqlalchemy.Column("description", sqlalchemy.String(255)),
-        sqlalchemy.Column('location', sqlalchemy.String(255)),
+        sqlalchemy.Column("location", sqlalchemy.String(255)),
-        sqlalchemy.Column('software_version', sqlalchemy.String(255)),
+        sqlalchemy.Column("software_version", sqlalchemy.String(255)),
-        sqlalchemy.Column('management_state', sqlalchemy.String(255)),
+        sqlalchemy.Column("management_state", sqlalchemy.String(255)),
-        sqlalchemy.Column('availability_status', sqlalchemy.String(255)),
+        sqlalchemy.Column("availability_status", sqlalchemy.String(255)),
-        sqlalchemy.Column('management_subnet', sqlalchemy.String(255)),
+        sqlalchemy.Column("management_subnet", sqlalchemy.String(255)),
-        sqlalchemy.Column('management_gateway_ip', sqlalchemy.String(255)),
+        sqlalchemy.Column("management_gateway_ip", sqlalchemy.String(255)),
-        sqlalchemy.Column('management_start_ip', sqlalchemy.String(255)),
+        sqlalchemy.Column("management_start_ip", sqlalchemy.String(255)),
-        sqlalchemy.Column('management_end_ip', sqlalchemy.String(255)),
+        sqlalchemy.Column("management_end_ip", sqlalchemy.String(255)),
-        sqlalchemy.Column('systemcontroller_gateway_ip',
+        sqlalchemy.Column("systemcontroller_gateway_ip", sqlalchemy.String(255)),
-                          sqlalchemy.String(255)),
+        sqlalchemy.Column("audit_fail_count", sqlalchemy.Integer, default=0),
-        sqlalchemy.Column('audit_fail_count', sqlalchemy.Integer, default=0),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer),
+        mysql_engine="InnoDB",
-        mysql_engine='InnoDB',
+        mysql_charset="utf8",
-        mysql_charset='utf8'
     )
 
     subcloud_status = sqlalchemy.Table(
-        'subcloud_status', meta,
+        "subcloud_status",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True, nullable=False),
+        sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True, nullable=False),
-        sqlalchemy.Column('subcloud_id', sqlalchemy.Integer,
+        sqlalchemy.Column(
-                          sqlalchemy.ForeignKey('subclouds.id',
+            "subcloud_id",
-                                                ondelete='CASCADE')),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('endpoint_type', sqlalchemy.String(255)),
+            sqlalchemy.ForeignKey("subclouds.id", ondelete="CASCADE"),
-        sqlalchemy.Column('sync_status', sqlalchemy.String(255)),
+        ),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("endpoint_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("sync_status", sqlalchemy.String(255)),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
-        mysql_engine='InnoDB',
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
-        mysql_charset='utf8'
+        sqlalchemy.Column("deleted", sqlalchemy.Integer),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8",
     )
 
     sw_update_strategy = sqlalchemy.Table(
-        'sw_update_strategy', meta,
+        "sw_update_strategy",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True, nullable=False),
+        sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True, nullable=False),
-        sqlalchemy.Column('type', sqlalchemy.String(255), unique=True),
+        sqlalchemy.Column("type", sqlalchemy.String(255), unique=True),
-        sqlalchemy.Column('subcloud_apply_type', sqlalchemy.String(255)),
+        sqlalchemy.Column("subcloud_apply_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('max_parallel_subclouds', sqlalchemy.Integer),
+        sqlalchemy.Column("max_parallel_subclouds", sqlalchemy.Integer),
-        sqlalchemy.Column('stop_on_failure', sqlalchemy.Boolean),
+        sqlalchemy.Column("stop_on_failure", sqlalchemy.Boolean),
-        sqlalchemy.Column('state', sqlalchemy.String(255)),
+        sqlalchemy.Column("state", sqlalchemy.String(255)),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer),
-        mysql_engine='InnoDB',
+        mysql_engine="InnoDB",
-        mysql_charset='utf8'
+        mysql_charset="utf8",
     )
 
     sw_update_opts_default = sqlalchemy.Table(
-        'sw_update_opts_default', meta,
+        "sw_update_opts_default",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True, nullable=False),
+        sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True, nullable=False),
-        sqlalchemy.Column('subcloud_id', sqlalchemy.Integer),
+        sqlalchemy.Column("subcloud_id", sqlalchemy.Integer),
-        sqlalchemy.Column('storage_apply_type', sqlalchemy.String(255)),
+        sqlalchemy.Column("storage_apply_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('compute_apply_type', sqlalchemy.String(255)),
+        sqlalchemy.Column("compute_apply_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('max_parallel_computes', sqlalchemy.Integer),
+        sqlalchemy.Column("max_parallel_computes", sqlalchemy.Integer),
-        sqlalchemy.Column('default_instance_action', sqlalchemy.String(255)),
+        sqlalchemy.Column("default_instance_action", sqlalchemy.String(255)),
-        sqlalchemy.Column('alarm_restriction_type', sqlalchemy.String(255)),
+        sqlalchemy.Column("alarm_restriction_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer),
-        mysql_engine='InnoDB',
+        mysql_engine="InnoDB",
-        mysql_charset='utf8'
+        mysql_charset="utf8",
     )
 
     sw_update_opts = sqlalchemy.Table(
-        'sw_update_opts', meta,
+        "sw_update_opts",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True, nullable=False),
+        sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True, nullable=False),
-        sqlalchemy.Column('subcloud_id', sqlalchemy.Integer,
+        sqlalchemy.Column(
-                          sqlalchemy.ForeignKey('subclouds.id',
+            "subcloud_id",
-                                                ondelete='CASCADE')),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('storage_apply_type', sqlalchemy.String(255)),
+            sqlalchemy.ForeignKey("subclouds.id", ondelete="CASCADE"),
-        sqlalchemy.Column('compute_apply_type', sqlalchemy.String(255)),
+        ),
-        sqlalchemy.Column('max_parallel_computes', sqlalchemy.Integer),
+        sqlalchemy.Column("storage_apply_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('default_instance_action', sqlalchemy.String(255)),
+        sqlalchemy.Column("compute_apply_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('alarm_restriction_type', sqlalchemy.String(255)),
+        sqlalchemy.Column("max_parallel_computes", sqlalchemy.Integer),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("default_instance_action", sqlalchemy.String(255)),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("alarm_restriction_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
-        mysql_engine='InnoDB',
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
-        mysql_charset='utf8'
+        sqlalchemy.Column("deleted", sqlalchemy.Integer),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8",
     )
 
     strategy_steps = sqlalchemy.Table(
-        'strategy_steps', meta,
+        "strategy_steps",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True, nullable=False),
+        sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True, nullable=False),
-        sqlalchemy.Column('subcloud_id', sqlalchemy.Integer,
+        sqlalchemy.Column(
-                          sqlalchemy.ForeignKey('subclouds.id',
+            "subcloud_id",
-                                                ondelete='CASCADE'),
+            sqlalchemy.Integer,
-                          unique=True),
+            sqlalchemy.ForeignKey("subclouds.id", ondelete="CASCADE"),
-        sqlalchemy.Column('stage', sqlalchemy.Integer),
+            unique=True,
-        sqlalchemy.Column('state', sqlalchemy.String(255)),
+        ),
-        sqlalchemy.Column('details', sqlalchemy.String(255)),
+        sqlalchemy.Column("stage", sqlalchemy.Integer),
-        sqlalchemy.Column('started_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("state", sqlalchemy.String(255)),
-        sqlalchemy.Column('finished_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("details", sqlalchemy.String(255)),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("started_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("finished_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
-        mysql_engine='InnoDB',
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
-        mysql_charset='utf8'
+        sqlalchemy.Column("deleted", sqlalchemy.Integer),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8",
     )
 
     tables = (
@@ -160,7 +165,7 @@ def upgrade(migrate_engine):
         sw_update_strategy,
         strategy_steps,
         sw_update_opts,
-        sw_update_opts_default
+        sw_update_opts_default,
     )
 
     for index, table in enumerate(tables):
@@ -176,18 +181,21 @@ def upgrade(migrate_engine):
         # populate the sw_update_opts_default with the default values.
         con = migrate_engine.connect()
 
-        con.execute(sw_update_opts_default.insert(),  # pylint: disable=E1120
+        con.execute(
-                    storage_apply_type=vim.APPLY_TYPE_PARALLEL,
+            sw_update_opts_default.insert(),  # pylint: disable=E1120
-                    compute_apply_type=vim.APPLY_TYPE_PARALLEL,
+            storage_apply_type=vim.APPLY_TYPE_PARALLEL,
-                    max_parallel_computes=10,
+            compute_apply_type=vim.APPLY_TYPE_PARALLEL,
-                    default_instance_action=vim.INSTANCE_ACTION_MIGRATE,
+            max_parallel_computes=10,
-                    alarm_restriction_type=vim.ALARM_RESTRICTIONS_RELAXED,
+            default_instance_action=vim.INSTANCE_ACTION_MIGRATE,
-                    deleted=0)
+            alarm_restriction_type=vim.ALARM_RESTRICTIONS_RELAXED,
+            deleted=0,
+        )
     except Exception:
         # We can survive if this fails.
         pass
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade not supported - '
+    raise NotImplementedError(
-                              'would drop all tables')
+        "Database downgrade not supported - would drop all tables"
+    )

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/002_rename_compute_to_worker.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2021 Wind River Systems, Inc.
+# Copyright (c) 2019-2021, 2024 Wind River Systems, Inc.
 # 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
@@ -20,12 +20,13 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    sw_update_opts_default = Table('sw_update_opts_default', meta,
+    sw_update_opts_default = Table("sw_update_opts_default", meta, autoload=True)
-                                   autoload=True)
+    sw_update_opts = Table("sw_update_opts", meta, autoload=True)
-    sw_update_opts = Table('sw_update_opts', meta, autoload=True)
 
-    columns_to_rename = {'compute_apply_type': 'worker_apply_type',
+    columns_to_rename = {
-                         'max_parallel_computes': 'max_parallel_workers'}
+        "compute_apply_type": "worker_apply_type",
+        "max_parallel_computes": "max_parallel_workers",
+    }
     for k, v in columns_to_rename.items():
         getattr(sw_update_opts_default.c, k).alter(name=v)
         getattr(sw_update_opts.c, k).alter(name=v)
@@ -34,4 +35,4 @@ def upgrade(migrate_engine):
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/003_add_deploy_status_column.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2021 Wind River Systems, Inc.
+# Copyright (c) 2019-2021, 2024 Wind River Systems, Inc.
 # 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
@@ -19,13 +19,13 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the 'deploy_status' column to the subclouds table.
-    subclouds.create_column(Column('deploy_status', String(255)))
+    subclouds.create_column(Column("deploy_status", String(255)))
 
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/004_add_openstack_installed_column.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2019-2021 Wind River Systems, Inc.
+# Copyright (c) 2019-2021, 2024 Wind River Systems, Inc.
 # 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
@@ -19,15 +19,21 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the 'openstack_installed' column to the subclouds table.
-    subclouds.create_column(Column('openstack_installed', Boolean,
+    subclouds.create_column(
-                                   nullable=False, default=False,
+        Column(
-                                   server_default='0'))
+            "openstack_installed",
+            Boolean,
+            nullable=False,
+            default=False,
+            server_default="0",
+        )
+    )
 
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/005_add_subcloud_alarms.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2021 Wind River Systems, Inc.
+# Copyright (c) 2020-2021, 2024 Wind River Systems, Inc.
 # 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
@@ -20,30 +20,28 @@ def upgrade(migrate_engine):
     meta.bind = migrate_engine
 
     subcloud_alarms = sqlalchemy.Table(
-        'subcloud_alarms', meta,
+        "subcloud_alarms",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True, nullable=False),
+        sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True, nullable=False),
-        sqlalchemy.Column('uuid', sqlalchemy.String(36), unique=True),
+        sqlalchemy.Column("uuid", sqlalchemy.String(36), unique=True),
-
+        sqlalchemy.Column("name", sqlalchemy.String(255), unique=True),
-        sqlalchemy.Column('name', sqlalchemy.String(255), unique=True),
+        sqlalchemy.Column("critical_alarms", sqlalchemy.Integer),
-        sqlalchemy.Column('critical_alarms', sqlalchemy.Integer),
+        sqlalchemy.Column("major_alarms", sqlalchemy.Integer),
-        sqlalchemy.Column('major_alarms', sqlalchemy.Integer),
+        sqlalchemy.Column("minor_alarms", sqlalchemy.Integer),
-        sqlalchemy.Column('minor_alarms', sqlalchemy.Integer),
+        sqlalchemy.Column("warnings", sqlalchemy.Integer),
-        sqlalchemy.Column('warnings', sqlalchemy.Integer),
+        sqlalchemy.Column("cloud_status", sqlalchemy.String(64)),
-        sqlalchemy.Column('cloud_status', sqlalchemy.String(64)),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
-
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        mysql_engine="InnoDB",
-        sqlalchemy.Column('deleted', sqlalchemy.Integer),
+        mysql_charset="utf8",
-
-        mysql_engine='InnoDB',
-        mysql_charset='utf8'
     )
 
     subcloud_alarms.create()
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade not supported - '
+    raise NotImplementedError(
-                              'would drop all tables')
+        "Database downgrade not supported - would drop all tables"
+    )

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/006_add_subcloud_group_table.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2021 Wind River Systems, Inc.
+# Copyright (c) 2020-2021, 2024 Wind River Systems, Inc.
 # 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
@@ -17,8 +17,8 @@ import sqlalchemy
 
 from dcmanager.common import consts
 
-ENGINE = 'InnoDB',
+ENGINE = ("InnoDB",)
-CHARSET = 'utf8'
+CHARSET = "utf8"
 
 
 def upgrade(migrate_engine):
@@ -26,27 +26,31 @@ def upgrade(migrate_engine):
 
     # Declare the new subcloud_group table
     subcloud_group = sqlalchemy.Table(
-        'subcloud_group', meta,
+        "subcloud_group",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True,
+        sqlalchemy.Column(
-                          autoincrement=True,
+            "id",
-                          nullable=False),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('name', sqlalchemy.String(255), unique=True),
+            primary_key=True,
-        sqlalchemy.Column('description', sqlalchemy.String(255)),
+            autoincrement=True,
-        sqlalchemy.Column('update_apply_type', sqlalchemy.String(255)),
+            nullable=False,
-        sqlalchemy.Column('max_parallel_subclouds', sqlalchemy.Integer),
+        ),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("name", sqlalchemy.String(255), unique=True),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("description", sqlalchemy.String(255)),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("update_apply_type", sqlalchemy.String(255)),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("max_parallel_subclouds", sqlalchemy.Integer),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer, default=0),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer, default=0),
         mysql_engine=ENGINE,
-        mysql_charset=CHARSET
+        mysql_charset=CHARSET,
     )
     subcloud_group.create()
 
-    subclouds = sqlalchemy.Table('subclouds', meta, autoload=True)
+    subclouds = sqlalchemy.Table("subclouds", meta, autoload=True)
 
     # TODO(abailey) do we want to fix the missing constraint for strategy_steps
     # strat_steps = sqlalchemy.Table('strategy_steps', meta, autoload=True)
@@ -62,37 +66,36 @@ def upgrade(migrate_engine):
         "name": consts.DEFAULT_SUBCLOUD_GROUP_NAME,
         "description": consts.DEFAULT_SUBCLOUD_GROUP_DESCRIPTION,
         "update_apply_type": consts.DEFAULT_SUBCLOUD_GROUP_UPDATE_APPLY_TYPE,
-        "max_parallel_subclouds":
+        "max_parallel_subclouds": consts.DEFAULT_SUBCLOUD_GROUP_MAX_PARALLEL_SUBCLOUDS,
-            consts.DEFAULT_SUBCLOUD_GROUP_MAX_PARALLEL_SUBCLOUDS,
+        "deleted": 0,
-        "deleted": 0
     }
     # Inserting the GROUP as ID 1,
     # This should increment the pkey to 2
     with migrate_engine.begin() as conn:
-        conn.execute(
+        conn.execute(subcloud_group.insert(), default_group)  # pylint: disable=E1120
-            subcloud_group.insert(),  # pylint: disable=E1120
-            default_group)
 
     # postgres does not increment the subcloud group id sequence
     # after the insert above as part of the migrate.
     # Note: use different SQL syntax if using mysql or sqlite
-    if migrate_engine.name == 'postgresql':
+    if migrate_engine.name == "postgresql":
         with migrate_engine.begin() as conn:
             conn.execute("ALTER SEQUENCE subcloud_group_id_seq RESTART WITH 2")
 
     # Add group_id column to subclouds table
-    group_id = \
+    group_id = sqlalchemy.Column(
-        sqlalchemy.Column('group_id',
+        "group_id",
-                          sqlalchemy.Integer,
+        sqlalchemy.Integer,
-                          server_default=str(consts.DEFAULT_SUBCLOUD_GROUP_ID))
+        server_default=str(consts.DEFAULT_SUBCLOUD_GROUP_ID),
+    )
     group_id.create(subclouds)
 
     subcloud_fkey = constraint.ForeignKeyConstraint(
         columns=[subclouds.c.group_id],
         refcolumns=[subcloud_group.c.id],
-        name='subclouds_group_ref')
+        name="subclouds_group_ref",
+    )
     subclouds.append_constraint(subcloud_fkey)
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/007_add_subcloud_install.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2021 Wind River Systems, Inc.
+# Copyright (c) 2020-2021, 2024 Wind River Systems, Inc.
 # 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
@@ -22,14 +22,14 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the 'data_install' to persist data_install data
-    subclouds.create_column(Column('data_install', Text))
+    subclouds.create_column(Column("data_install", Text))
 
     # Add the data_upgrade which persist over an upgrade
-    subclouds.create_column(Column('data_upgrade', Text))
+    subclouds.create_column(Column("data_upgrade", Text))
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/008_add_subcloud_audits_table.py

@@ -29,40 +29,47 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
     subcloud_audits = Table(
-        'subcloud_audits', meta,
+        "subcloud_audits",
-        Column('id', Integer, primary_key=True,
+        meta,
-               autoincrement=True, nullable=False),
+        Column("id", Integer, primary_key=True, autoincrement=True, nullable=False),
-        Column('subcloud_id', Integer,
+        Column(
-               ForeignKey('subclouds.id', ondelete='CASCADE'),
+            "subcloud_id",
-               unique=True),
+            Integer,
-        Column('created_at', DateTime),
+            ForeignKey("subclouds.id", ondelete="CASCADE"),
-        Column('updated_at', DateTime),
+            unique=True,
-        Column('deleted_at', DateTime),
+        ),
-        Column('deleted', Integer, default=0),
+        Column("created_at", DateTime),
-        Column('audit_started_at', DateTime, default=datetime.datetime.min),
+        Column("updated_at", DateTime),
-        Column('audit_finished_at', DateTime, default=datetime.datetime.min),
+        Column("deleted_at", DateTime),
-        Column('state_update_requested', Boolean, nullable=False, default=False),
+        Column("deleted", Integer, default=0),
-        Column('patch_audit_requested', Boolean, nullable=False, default=False),
+        Column("audit_started_at", DateTime, default=datetime.datetime.min),
-        Column('load_audit_requested', Boolean, nullable=False, default=False),
+        Column("audit_finished_at", DateTime, default=datetime.datetime.min),
-        Column('firmware_audit_requested', Boolean, nullable=False, default=False),
+        Column("state_update_requested", Boolean, nullable=False, default=False),
-        Column('kubernetes_audit_requested', Boolean, nullable=False, default=False),
+        Column("patch_audit_requested", Boolean, nullable=False, default=False),
-        Column('spare_audit_requested', Boolean, nullable=False, default=False),
+        Column("load_audit_requested", Boolean, nullable=False, default=False),
-        Column('spare2_audit_requested', Boolean, nullable=False, default=False),
+        Column("firmware_audit_requested", Boolean, nullable=False, default=False),
-        Column('reserved', Text),
+        Column("kubernetes_audit_requested", Boolean, nullable=False, default=False),
-        mysql_engine='InnoDB',
+        Column("spare_audit_requested", Boolean, nullable=False, default=False),
-        mysql_charset='utf8'
+        Column("spare2_audit_requested", Boolean, nullable=False, default=False),
+        Column("reserved", Text),
+        mysql_engine="InnoDB",
+        mysql_charset="utf8",
     )
     subcloud_audits.create()
 
     # Create rows in the new table for each non-deleted subcloud.
-    subcloud_list = list(subclouds.select().where(subclouds.c.deleted == 0)
+    subcloud_list = list(
-                         .order_by(subclouds.c.id).execute())
+        subclouds.select()
+        .where(subclouds.c.deleted == 0)
+        .order_by(subclouds.c.id)
+        .execute()
+    )
     for subcloud in subcloud_list:
         # pylint: disable-next=no-value-for-parameter
-        subcloud_audits.insert().execute({'subcloud_id': subcloud['id']})
+        subcloud_audits.insert().execute({"subcloud_id": subcloud["id"]})
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/009_add_kube_rootca_audit.py

@@ -1,8 +1,9 @@
 #
-# Copyright (c) 2021 Wind River Systems, Inc.
+# Copyright (c) 2021, 2024 Wind River Systems, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 #
+
 from sqlalchemy import Boolean
 from sqlalchemy import Column
 from sqlalchemy import MetaData
@@ -13,16 +14,20 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subcloud_audits = Table('subcloud_audits', meta, autoload=True)
+    subcloud_audits = Table("subcloud_audits", meta, autoload=True)
 
     # Add the kube_rootca_update_audit_requested  column to the audits table.
-    subcloud_audits.create_column(Column('kube_rootca_update_audit_requested',
+    subcloud_audits.create_column(
-                                         Boolean,
+        Column(
-                                         nullable=False,
+            "kube_rootca_update_audit_requested",
-                                         default=False,
+            Boolean,
-                                         server_default='0'))
+            nullable=False,
+            default=False,
+            server_default="0",
+        )
+    )
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/010_add_update_extra_args.py

@@ -1,8 +1,9 @@
 #
-# Copyright (c) 2021 Wind River Systems, Inc.
+# Copyright (c) 2021, 2024 Wind River Systems, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 #
+
 import sqlalchemy
 
 
@@ -11,14 +12,11 @@ def upgrade(migrate_engine):
     meta.bind = migrate_engine
 
     # Add the 'extra_args' column to the sw_update_strategy table.
-    sw_update_strategy = sqlalchemy.Table('sw_update_strategy',
+    sw_update_strategy = sqlalchemy.Table("sw_update_strategy", meta, autoload=True)
-                                          meta,
-                                          autoload=True)
     # JSONEncodedDict is stored in the database as Text
-    sw_update_strategy.create_column(sqlalchemy.Column('extra_args',
+    sw_update_strategy.create_column(sqlalchemy.Column("extra_args", sqlalchemy.Text))
-                                                       sqlalchemy.Text))
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/011_add_subcloud_backup_columns.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2022 Wind River Systems, Inc.
+# Copyright (c) 2022, 2024 Wind River Systems, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 #
@@ -11,14 +11,14 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the backup-related columns to the subclouds table.
-    subclouds.create_column(Column('backup_status', String(255)))
+    subclouds.create_column(Column("backup_status", String(255)))
-    subclouds.create_column(Column('backup_datetime', DateTime(timezone=False)))
+    subclouds.create_column(Column("backup_datetime", DateTime(timezone=False)))
 
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/012_add_deploy_error_desc_column.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2022 Wind River Systems, Inc.
+# Copyright (c) 2022, 2024 Wind River Systems, Inc.
 # 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
@@ -19,15 +19,15 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the 'error_description' column to the subclouds table.
-    subclouds.create_column(Column('error_description',
+    subclouds.create_column(
-                                   String(2048),
+        Column("error_description", String(2048), default="No errors present")
-                                   default="No errors present"))
+    )
 
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/013_add_subcloud_region_name_column.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Wind River Systems, Inc.
+# Copyright (c) 2023-2024 Wind River Systems, Inc.
 # 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
@@ -19,14 +19,13 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the 'region_name' column to the subclouds table.
-    subclouds.create_column(Column('region_name',
+    subclouds.create_column(Column("region_name", String(255)))
-                                   String(255)))
 
     # populates region_name with name field value for existing subclouds
-    if migrate_engine.name == 'postgresql':
+    if migrate_engine.name == "postgresql":
         with migrate_engine.begin() as conn:
             conn.execute("UPDATE subclouds SET region_name = name")
 
@@ -34,4 +33,4 @@ def upgrade(migrate_engine):
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/014_add_subcloud_peer_group_and_association.py

@@ -1,106 +1,122 @@
-# Copyright (c) 2023 Wind River Systems, Inc.
+# Copyright (c) 2023-2024 Wind River Systems, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 #
 
 import sqlalchemy
 
-ENGINE = 'InnoDB',
+ENGINE = ("InnoDB",)
-CHARSET = 'utf8'
+CHARSET = "utf8"
 
 
 def upgrade(migrate_engine):
     meta = sqlalchemy.MetaData(bind=migrate_engine)
 
-    subclouds = sqlalchemy.Table('subclouds', meta, autoload=True)
+    subclouds = sqlalchemy.Table("subclouds", meta, autoload=True)
     # Add the 'rehome_data' column to the subclouds table.
-    subclouds.create_column(sqlalchemy.Column('rehome_data', sqlalchemy.Text))
+    subclouds.create_column(sqlalchemy.Column("rehome_data", sqlalchemy.Text))
 
     # Declare the new subcloud_peer_group table
     subcloud_peer_group = sqlalchemy.Table(
-        'subcloud_peer_group', meta,
+        "subcloud_peer_group",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True,
+        sqlalchemy.Column(
-                          autoincrement=True,
+            "id",
-                          nullable=False),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('peer_group_name', sqlalchemy.String(255), unique=True),
+            primary_key=True,
-        sqlalchemy.Column('group_priority', sqlalchemy.Integer),
+            autoincrement=True,
-        sqlalchemy.Column('group_state', sqlalchemy.String(255)),
+            nullable=False,
-        sqlalchemy.Column('system_leader_id', sqlalchemy.String(255)),
+        ),
-        sqlalchemy.Column('system_leader_name', sqlalchemy.String(255)),
+        sqlalchemy.Column("peer_group_name", sqlalchemy.String(255), unique=True),
-        sqlalchemy.Column('max_subcloud_rehoming', sqlalchemy.Integer),
+        sqlalchemy.Column("group_priority", sqlalchemy.Integer),
-        sqlalchemy.Column('migration_status', sqlalchemy.String(255)),
+        sqlalchemy.Column("group_state", sqlalchemy.String(255)),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("system_leader_id", sqlalchemy.String(255)),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("system_leader_name", sqlalchemy.String(255)),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("max_subcloud_rehoming", sqlalchemy.Integer),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("migration_status", sqlalchemy.String(255)),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer, default=0),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer, default=0),
         mysql_engine=ENGINE,
-        mysql_charset=CHARSET
+        mysql_charset=CHARSET,
     )
     subcloud_peer_group.create()
     # Add the 'peer_greoup_id' column to the subclouds table.
-    subclouds.create_column(sqlalchemy.Column('peer_group_id', sqlalchemy.Integer))
+    subclouds.create_column(sqlalchemy.Column("peer_group_id", sqlalchemy.Integer))
 
     # Declare the new system_peer table
     system_peer = sqlalchemy.Table(
-        'system_peer', meta,
+        "system_peer",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True,
+        sqlalchemy.Column(
-                          autoincrement=True,
+            "id",
-                          nullable=False),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('peer_uuid', sqlalchemy.String(36), unique=True),
+            primary_key=True,
-        sqlalchemy.Column('peer_name', sqlalchemy.String(255), unique=True),
+            autoincrement=True,
-        sqlalchemy.Column('manager_endpoint', sqlalchemy.String(255)),
+            nullable=False,
-        sqlalchemy.Column('manager_username', sqlalchemy.String(255)),
+        ),
-        sqlalchemy.Column('manager_password', sqlalchemy.String(255)),
+        sqlalchemy.Column("peer_uuid", sqlalchemy.String(36), unique=True),
-        sqlalchemy.Column('peer_controller_gateway_ip', sqlalchemy.String(255)),
+        sqlalchemy.Column("peer_name", sqlalchemy.String(255), unique=True),
-        sqlalchemy.Column('administrative_state', sqlalchemy.String(255)),
+        sqlalchemy.Column("manager_endpoint", sqlalchemy.String(255)),
-        sqlalchemy.Column('heartbeat_interval', sqlalchemy.Integer),
+        sqlalchemy.Column("manager_username", sqlalchemy.String(255)),
-        sqlalchemy.Column('heartbeat_failure_threshold', sqlalchemy.Integer),
+        sqlalchemy.Column("manager_password", sqlalchemy.String(255)),
-        sqlalchemy.Column('heartbeat_failure_policy', sqlalchemy.String(255)),
+        sqlalchemy.Column("peer_controller_gateway_ip", sqlalchemy.String(255)),
-        sqlalchemy.Column('heartbeat_maintenance_timeout', sqlalchemy.Integer),
+        sqlalchemy.Column("administrative_state", sqlalchemy.String(255)),
-        sqlalchemy.Column('availability_state', sqlalchemy.String(255)),
+        sqlalchemy.Column("heartbeat_interval", sqlalchemy.Integer),
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+        sqlalchemy.Column("heartbeat_failure_threshold", sqlalchemy.Integer),
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+        sqlalchemy.Column("heartbeat_failure_policy", sqlalchemy.String(255)),
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("heartbeat_maintenance_timeout", sqlalchemy.Integer),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("availability_state", sqlalchemy.String(255)),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer, default=0),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer, default=0),
         mysql_engine=ENGINE,
-        mysql_charset=CHARSET
+        mysql_charset=CHARSET,
     )
     system_peer.create()
 
     # Declare the new peer_group_association table
     peer_group_association = sqlalchemy.Table(
-        'peer_group_association', meta,
+        "peer_group_association",
-        sqlalchemy.Column('id', sqlalchemy.Integer,
+        meta,
-                          primary_key=True,
+        sqlalchemy.Column(
-                          autoincrement=True,
+            "id",
-                          nullable=False),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('peer_group_id', sqlalchemy.Integer,
+            primary_key=True,
-                          sqlalchemy.ForeignKey('subcloud_peer_group.id',
+            autoincrement=True,
-                                                ondelete='CASCADE')),
+            nullable=False,
-        sqlalchemy.Column('system_peer_id', sqlalchemy.Integer,
+        ),
-                          sqlalchemy.ForeignKey('system_peer.id',
+        sqlalchemy.Column(
-                                                ondelete='CASCADE')),
+            "peer_group_id",
-        sqlalchemy.Column('peer_group_priority', sqlalchemy.Integer),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('association_type', sqlalchemy.String(255)),
+            sqlalchemy.ForeignKey("subcloud_peer_group.id", ondelete="CASCADE"),
-        sqlalchemy.Column('sync_status', sqlalchemy.String(255)),
+        ),
-        sqlalchemy.Column('sync_message', sqlalchemy.Text),
+        sqlalchemy.Column(
-        sqlalchemy.Column('reserved_1', sqlalchemy.Text),
+            "system_peer_id",
-        sqlalchemy.Column('reserved_2', sqlalchemy.Text),
+            sqlalchemy.Integer,
-        sqlalchemy.Column('created_at', sqlalchemy.DateTime),
+            sqlalchemy.ForeignKey("system_peer.id", ondelete="CASCADE"),
-        sqlalchemy.Column('updated_at', sqlalchemy.DateTime),
+        ),
-        sqlalchemy.Column('deleted_at', sqlalchemy.DateTime),
+        sqlalchemy.Column("peer_group_priority", sqlalchemy.Integer),
-        sqlalchemy.Column('deleted', sqlalchemy.Integer, default=0),
+        sqlalchemy.Column("association_type", sqlalchemy.String(255)),
+        sqlalchemy.Column("sync_status", sqlalchemy.String(255)),
+        sqlalchemy.Column("sync_message", sqlalchemy.Text),
+        sqlalchemy.Column("reserved_1", sqlalchemy.Text),
+        sqlalchemy.Column("reserved_2", sqlalchemy.Text),
+        sqlalchemy.Column("created_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("updated_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted_at", sqlalchemy.DateTime),
+        sqlalchemy.Column("deleted", sqlalchemy.Integer, default=0),
         mysql_engine=ENGINE,
-        mysql_charset=CHARSET
+        mysql_charset=CHARSET,
     )
     peer_group_association.create()
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/015_add_subcloud_rehome_flag_column.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2023 Wind River Systems, Inc.
+# Copyright (c) 2023-2024 Wind River Systems, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 #
@@ -11,13 +11,13 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the 'rehomed' column to the subclouds table.
-    subclouds.create_column(Column('rehomed', Boolean, default=False))
+    subclouds.create_column(Column("rehomed", Boolean, default=False))
 
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/016_first_identity_sync_complete.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Wind River Systems, Inc.
+# Copyright (c) 2023-2024 Wind River Systems, Inc.
 # 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
@@ -18,13 +18,16 @@ import sqlalchemy
 def upgrade(migrate_engine):
     meta = sqlalchemy.MetaData()
     meta.bind = migrate_engine
-    subcloud = sqlalchemy.Table('subclouds', meta, autoload=True)
+    subcloud = sqlalchemy.Table("subclouds", meta, autoload=True)
     # Add the first_identity_sync_complete column
-    subcloud.create_column(sqlalchemy.Column('first_identity_sync_complete',
+    subcloud.create_column(
-                                             sqlalchemy.Boolean,
+        sqlalchemy.Column(
-                                             default=False))
+            "first_identity_sync_complete", sqlalchemy.Boolean, default=False
+        )
+    )
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade not supported - '
+    raise NotImplementedError(
-                              'would drop all tables')
+        "Database downgrade not supported - would drop all tables"
+    )

distributedcloud/dcmanager/db/sqlalchemy/migrate_repo/versions/017_add_subcloud_prestage_columns.py

@@ -11,20 +11,20 @@ def upgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine
 
-    subclouds = Table('subclouds', meta, autoload=True)
+    subclouds = Table("subclouds", meta, autoload=True)
 
     # Add the 'prestage_status' and 'prestage_versions' columns to
     # the subclouds table.
-    subclouds.create_column(Column('prestage_status', String(255)))
+    subclouds.create_column(Column("prestage_status", String(255)))
-    subclouds.create_column(Column('prestage_versions', String(255)))
+    subclouds.create_column(Column("prestage_versions", String(255)))
 
     # Update existing subclouds that have the old prestaging deploy status
     subclouds.update().where(  # pylint: disable=E1120
-        subclouds.c.deploy_status.like('prestage%')).values(
+        subclouds.c.deploy_status.like("prestage%")
-        {'deploy_status': 'complete'}).execute()
+    ).values({"deploy_status": "complete"}).execute()
 
     return True
 
 
 def downgrade(migrate_engine):
-    raise NotImplementedError('Database downgrade is unsupported.')
+    raise NotImplementedError("Database downgrade is unsupported.")

distributedcloud/dcmanager/db/sqlalchemy/migration.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2015 Ericsson AB.
-# Copyright (c) 2017, 2019, 2021 Wind River Systems, Inc.
+# Copyright (c) 2017, 2019, 2021, 2024 Wind River Systems, Inc.
 # All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -24,19 +24,15 @@ INIT_VERSION = 0
 
 
 def db_sync(engine, version=None):
-    path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+    path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "migrate_repo")
-                        'migrate_repo')
+    return oslo_migration.db_sync(engine, path, version, init_version=INIT_VERSION)
-    return oslo_migration.db_sync(engine, path, version,
-                                  init_version=INIT_VERSION)
 
 
 def db_version(engine):
-    path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+    path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "migrate_repo")
-                        'migrate_repo')
     return oslo_migration.db_version(engine, path, INIT_VERSION)
 
 
 def db_version_control(engine, version=None):
-    path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+    path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "migrate_repo")
-                        'migrate_repo')
     return oslo_migration.db_version_control(engine, path, version)

distributedcloud/dcmanager/db/sqlalchemy/models.py

@@ -62,9 +62,7 @@ class JSONEncodedDict(TypeDecorator):
         return value
 
 
-class DCManagerBase(models.ModelBase,
+class DCManagerBase(models.ModelBase, models.SoftDeleteMixin, models.TimestampMixin):
-                    models.SoftDeleteMixin,
-                    models.TimestampMixin):
     """Base class for DC Manager Models."""
 
     # __table_args__ = {'mysql_engine': 'InnoDB'}
@@ -98,7 +96,7 @@ class DCManagerBase(models.ModelBase,
 class SystemPeer(BASE, DCManagerBase):
     """Represents a system peer"""
 
-    __tablename__ = 'system_peer'
+    __tablename__ = "system_peer"
 
     id = Column(Integer, primary_key=True, autoincrement=True, nullable=False)
     peer_uuid = Column(String(36), unique=True)
@@ -118,7 +116,7 @@ class SystemPeer(BASE, DCManagerBase):
 class SubcloudGroup(BASE, DCManagerBase):
     """Represents a subcloud group"""
 
-    __tablename__ = 'subcloud_group'
+    __tablename__ = "subcloud_group"
 
     id = Column(Integer, primary_key=True, autoincrement=True, nullable=False)
     name = Column(String(255), unique=True)
@@ -130,7 +128,7 @@ class SubcloudGroup(BASE, DCManagerBase):
 class SubcloudPeerGroup(BASE, DCManagerBase):
     """Represents a subcloud group"""
 
-    __tablename__ = 'subcloud_peer_group'
+    __tablename__ = "subcloud_peer_group"
 
     id = Column(Integer, primary_key=True, autoincrement=True, nullable=False)
     peer_group_name = Column(String(255), unique=True)
@@ -145,7 +143,7 @@ class SubcloudPeerGroup(BASE, DCManagerBase):
 class PeerGroupAssociation(BASE, DCManagerBase):
     """Represents a Peer Group Association"""
 
-    __tablename__ = 'peer_group_association'
+    __tablename__ = "peer_group_association"
 
     id = Column(Integer, primary_key=True, autoincrement=True, nullable=False)
     peer_group_id = Column(Integer)
@@ -159,7 +157,7 @@ class PeerGroupAssociation(BASE, DCManagerBase):
 class Subcloud(BASE, DCManagerBase):
     """Represents a subcloud"""
 
-    __tablename__ = 'subclouds'
+    __tablename__ = "subclouds"
 
     id = Column(Integer, primary_key=True, nullable=False)
     name = Column(String(255), unique=True)
@@ -183,43 +181,34 @@ class Subcloud(BASE, DCManagerBase):
     systemcontroller_gateway_ip = Column(String(255))
     audit_fail_count = Column(Integer)
     first_identity_sync_complete = Column(Boolean, default=False)
-    peer_group_id = Column(Integer,
+    peer_group_id = Column(Integer, ForeignKey("subcloud_peer_group.id"))
-                           ForeignKey('subcloud_peer_group.id'))
     rehome_data = Column(Text())
     prestage_status = Column(String(255))
     prestage_versions = Column(String(255))
 
     # multiple subclouds can be in a particular group
-    group_id = Column(Integer,
+    group_id = Column(Integer, ForeignKey("subcloud_group.id"))
-                      ForeignKey('subcloud_group.id'))
+    group = relationship(SubcloudGroup, backref=backref("subcloud"))
-    group = relationship(SubcloudGroup,
-                         backref=backref('subcloud'))
     rehomed = Column(Boolean, default=False)
 
 
 class SubcloudAudits(BASE, DCManagerBase):
     """Represents the various audits for a subcloud"""
 
-    __tablename__ = 'subcloud_audits'
+    __tablename__ = "subcloud_audits"
 
     id = Column(Integer, primary_key=True, nullable=False)
     subcloud_id = Column(
-        Integer, ForeignKey('subclouds.id', ondelete='CASCADE'), unique=True
+        Integer, ForeignKey("subclouds.id", ondelete="CASCADE"), unique=True
-    )
-    audit_started_at = Column(
-        DateTime(timezone=False), default=datetime.datetime.min
-    )
-    audit_finished_at = Column(
-        DateTime(timezone=False), default=datetime.datetime.min
     )
+    audit_started_at = Column(DateTime(timezone=False), default=datetime.datetime.min)
+    audit_finished_at = Column(DateTime(timezone=False), default=datetime.datetime.min)
     state_update_requested = Column(Boolean, nullable=False, default=False)
     patch_audit_requested = Column(Boolean, nullable=False, default=False)
     load_audit_requested = Column(Boolean, nullable=False, default=False)
     firmware_audit_requested = Column(Boolean, nullable=False, default=False)
     kubernetes_audit_requested = Column(Boolean, nullable=False, default=False)
-    kube_rootca_update_audit_requested = Column(
+    kube_rootca_update_audit_requested = Column(Boolean, nullable=False, default=False)
-        Boolean, nullable=False, default=False
-    )
     spare_audit_requested = Column(Boolean, nullable=False, default=False)
     spare2_audit_requested = Column(Boolean, nullable=False, default=False)
     reserved = Column(Text)
@@ -231,8 +220,7 @@ class SubcloudStatus(BASE, DCManagerBase):
     __tablename__ = "subcloud_status"
 
     id = Column(Integer, primary_key=True, nullable=False)
-    subcloud_id = Column(Integer,
+    subcloud_id = Column(Integer, ForeignKey("subclouds.id", ondelete="CASCADE"))
-                         ForeignKey('subclouds.id', ondelete='CASCADE'))
     endpoint_type = Column(String(255))
     sync_status = Column(String(255))
 
@@ -257,8 +245,7 @@ class SwUpdateOpts(BASE, DCManagerBase):
     __tablename__ = "sw_update_opts"
 
     id = Column(Integer, primary_key=True, nullable=False)
-    subcloud_id = Column(Integer,
+    subcloud_id = Column(Integer, ForeignKey("subclouds.id", ondelete="CASCADE"))
-                         ForeignKey('subclouds.id', ondelete='CASCADE'))
 
     storage_apply_type = Column(String(255))
     worker_apply_type = Column(String(255))
@@ -288,26 +275,28 @@ class StrategyStep(BASE, DCManagerBase):
     __tablename__ = "strategy_steps"
 
     id = Column(Integer, primary_key=True, nullable=False)
-    subcloud_id = Column(Integer,
+    subcloud_id = Column(
-                         ForeignKey('subclouds.id', ondelete='CASCADE'),
+        Integer, ForeignKey("subclouds.id", ondelete="CASCADE"), unique=True
-                         unique=True)
+    )
     stage = Column(Integer)
     state = Column(String(255))
     details = Column(String(255))
     started_at = Column(DateTime)
     finished_at = Column(DateTime)
-    subcloud = relationship('Subcloud', backref=backref("strategy_steps",
+    subcloud = relationship(
-                                                        cascade="all,delete"))
+        "Subcloud", backref=backref("strategy_steps", cascade="all,delete")
+    )
 
 
 class SubcloudAlarmSummary(BASE, DCManagerBase):
     """Represents a Distributed Cloud subcloud alarm aggregate"""
-    __tablename__ = 'subcloud_alarms'
+
+    __tablename__ = "subcloud_alarms"
     id = Column(Integer, primary_key=True, nullable=False, autoincrement=True)
     uuid = Column(String(36), unique=True)
-    name = Column('name', String(255), unique=True)
+    name = Column("name", String(255), unique=True)
-    critical_alarms = Column('critical_alarms', Integer)
+    critical_alarms = Column("critical_alarms", Integer)
-    major_alarms = Column('major_alarms', Integer)
+    major_alarms = Column("major_alarms", Integer)
-    minor_alarms = Column('minor_alarms', Integer)
+    minor_alarms = Column("minor_alarms", Integer)
-    warnings = Column('warnings', Integer)
+    warnings = Column("warnings", Integer)
-    cloud_status = Column('cloud_status', String(64))
+    cloud_status = Column("cloud_status", String(64))

distributedcloud/dcmanager/db/utils.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2015 Ericsson AB.
-# Copyright (c) 2017, 2019, 2021, 2022 Wind River Systems, Inc.
+# Copyright (c) 2017, 2019, 2021, 2022, 2024 Wind River Systems, Inc.
 # All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -47,8 +47,8 @@ class LazyPluggable(object):
         return getattr(backend, key)
 
 
-IMPL = LazyPluggable('backend', sqlalchemy='dcmanager.db.sqlalchemy.api')
+IMPL = LazyPluggable("backend", sqlalchemy="dcmanager.db.sqlalchemy.api")
 
 
-def purge_deleted(age, granularity='days'):
+def purge_deleted(age, granularity="days"):
     IMPL.purge_deleted(age, granularity)

distributedcloud/run_black.py

@@ -27,6 +27,7 @@ formatted_modules = [
     "dcmanager/api",
     "dcmanager/audit",
     "dcmanager/common",
+    "dcmanager/db",
 ]