# Copyright (c) 2021, 2024, Oracle and/or its affiliates. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License, version 2.0, # as published by the Free Software Foundation. # # This program is designed to work with certain software (including # but not limited to OpenSSL) that is licensed under separate terms, as # designated in a particular file or component or in included license # documentation. The authors of MySQL hereby grant you an additional # permission to link the program and your derivative works with the # separately licensed software that they have either included with # the program or referenced in the documentation. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See # the GNU General Public License, version 2.0, for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA """Sub-Module to manage the MySQL DbSystems""" from mds_plugin import core, configuration, util from mysqlsh.plugin_manager import plugin_function DB_SYSTEM_ACTION_START = 1 DB_SYSTEM_ACTION_STOP = 2 DB_SYSTEM_ACTION_RESTART = 3 HW_CLUSTER_ACTION_START = 4 HW_CLUSTER_ACTION_STOP = 5 HW_CLUSTER_ACTION_RESTART = 6 def format_db_systems(items, current=None) -> str: """Formats a given list of objects in a human readable form Args: items: Either a list of objects or a single object current (str): OCID of the current item Returns: The db_systems formatted as str """ # If a single db_system was given, wrap it in a list if not type(items) is list: items = [items] # return objects in READABLE text output out = "" id = 1 for i in items: index = f"*{id:>3} " if current == i.id else f"{id:>4} " kind = " " if hasattr(i, "is_supported_for_hw_cluster") and i.is_supported_for_hw_cluster: kind = "HW" elif hasattr(i, "is_supported_for_analytics_cluster") and i.is_supported_for_analytics_cluster: kind = "AN" out += (index + core.fixed_len(i.display_name, 24, ' ', True) + core.fixed_len(i.description, 42, ' ', True) + core.fixed_len(i.mysql_version, 11, ' ') + core.fixed_len(i.lifecycle_state, 11, ' ' + kind + '\n')) id += 1 return out def format_db_system_config(items) -> str: """Formats a given list of objects in a human readable form Args: items: Either a list of objects or a single object Returns: The objects formatted as str """ # If a single db_system was given, wrap it in a list if not type(items) is list: items = [items] # return objects in READABLE text output out = "" id = 1 for i in items: out += (f"{id:>4} " + core.fixed_len(i.display_name, 32, ' ', True) + core.fixed_len(i.description, 35, ' ', True) + core.fixed_len(i.shape_name, 20, ' ') + core.fixed_len(i.lifecycle_state, 11, '\n')) id += 1 return out def format_mysql_shapes(items) -> str: """Formats a given list of objects in a human readable form Args: items: Either a list of objects or a single object Returns: The objects formatted as str """ # If a single db_system was given, wrap it in a list if not type(items) is list: items = [items] # return objects in READABLE text output out = (core.fixed_len('Shape Name', 32, ' ') + core.fixed_len('CPU Count', 12, ' ', align_right=True) + core.fixed_len('Memory Size', 12, '\n', align_right=True)) id = 1 for i in items: out += (f"{id:>4} " + core.fixed_len(i.name, 32, ' ', True) + core.fixed_len(str(i.cpu_core_count), 12, ' ', align_right=True) + core.fixed_len(str(i.memory_size_in_gbs) + ' GB', 12, '\n', align_right=True)) id += 1 return out def get_db_system_by_id(db_system_id, config=None): """Gets a DbSystem with the given id Args: db_system_id (str): OCID of the DbSystem. config (object): An OCI config object or None. Returns: None """ import oci.mysql # Initialize the DbSystem client db_sys = core.get_oci_db_system_client(config=config) # Get the DbSystems with the given db_system_id db_system = db_sys.get_db_system(db_system_id=db_system_id).data return db_system @plugin_function('mds.get.dbSystemConfiguration', shell=True, cli=True, web=True) def get_db_system_configuration(**kwargs): """Gets a DB System Config If no name is given, the user can select from a list. Args: **kwargs: Optional parameters Keyword Args: config_name (str): The name of the config. configuration_id (str): The OCID of the configuration. shape (str): The name of the compute shape. availability_domain (str): The name of the availability domain. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised return_formatted (bool): If true a human readable string is returned return_python_object (bool): Used for internal plugin calls Returns: The MySQL configuration object """ config_name = kwargs.get("config_name") configuration_id = kwargs.get("configuration_id") availability_domain = kwargs.get("availability_domain") shape = kwargs.get("shape") compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) return_formatted = kwargs.get("return_formatted", interactive) return_python_object = kwargs.get("return_python_object", False) # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) import oci.mysql from mds_plugin import compartment, compute try: # Get MDS Client mds_client = core.get_oci_mds_client(config=config) # If an configuration_id was given, look it up if configuration_id is not None: return core.return_oci_object( oci_object=mds_client.get_configuration( configuration_id=configuration_id), return_python_object=return_python_object, return_formatted=return_formatted, format_function=format_db_system_config) if not availability_domain: # Get the availability_domain name availability_domain_obj = compartment.get_availability_domain( random_selection=not interactive, compartment_id=compartment_id, availability_domain=availability_domain, config=config, interactive=interactive, return_python_object=True) if availability_domain_obj is None: raise ValueError("No availability domain specified.") availability_domain = availability_domain_obj.name # Get the shapes shape_id = compute.get_shape_name( shape_name=shape, compartment_id=compartment_id, availability_domain=availability_domain, config=config, interactive=interactive) if shape_id is None or shape_id == "": raise ValueError("No shape specified.") # Get list of configs configs = mds_client.list_configurations(compartment_id).data # Only consider configs that support the given shape configs = [c for c in configs if c.shape_name == shape_id] for config in configs: if config.display_name == config_name: return core.return_oci_object( oci_object=config, return_python_object=return_python_object, return_formatted=return_formatted, format_function=format_db_system_config) # If there is only a single config, use it if len(configs) == 1 or not interactive: return core.return_oci_object( oci_object=configs[0], return_python_object=return_python_object, return_formatted=return_formatted, format_function=format_db_system_config) # Let the user choose from the list print(f"\nPlease choose a MySQL Configuration from this list.\n") config = core.prompt_for_list_item( item_list=configs, prompt_caption="Please enter the name or index of the MySQL config: ", item_name_property="display_name", given_value=config_name, print_list=True) return core.return_oci_object( oci_object=config, return_python_object=return_python_object, return_formatted=return_formatted, format_function=format_db_system_config) except oci.exceptions.ServiceError as e: if raise_exceptions: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') except Exception as e: if raise_exceptions: raise print(f'ERROR: {e}') def get_mysql_version(mysql_version=None, compartment_id=None, config=None): """Gets a MySQL version If a mysql_version is given, it is checked if that mysql_version is available. Otherwise the user can select a different version Args: mysql_version (str): The mysql_version. compartment_id (str): The OCID of the compartment. config (object): An OCI config object or None. Returns: None """ # Get the active config and compartment try: config = configuration.get_current_config(config=config) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) except ValueError as e: print(f"ERROR: {str(e)}") return import oci.mysql from mds_plugin import compartment, compute # Get MDS Client mds_client = core.get_oci_mds_client(config=config) # Get list of versions version_summaries = mds_client.list_versions(compartment_id).data versions = [] for vs in version_summaries: versions += vs.versions if len(versions) == 1: return versions[0].version # Let the user choose from the list if mysql_version is None: print(f"\nPlease choose a MySQL Version from this list.\n") version = core.prompt_for_list_item( item_list=versions, prompt_caption="Please enter the MySQL version or index: ", item_name_property="version", given_value=mysql_version, print_list=True) return None if version is None else version.version def validate_mysql_password(password): """Validates the given password using the default MDS MySQL password rules - Should have at least one number. - Should have at least one uppercase and one lowercase character. - Should have at least one special symbol. - Should be between 8 to 20 characters long. Args: password (str): The password to validate Returns: True if the given password is valid, False otherwise """ import re reg = (r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])" r"[A-Za-z\d@$!#%*?&]{6,20}$") # compiling regex pattern = re.compile(reg) # searching regex return re.search(pattern, password) def get_validated_mysql_password(password_caption, print_password_rules=True): """Gets a validated password using the default MDS MySQL password rules - Should have at least one number. - Should have at least one uppercase and one lowercase character. - Should have at least one special symbol. - Should be between 8 to 20 characters long. Args: prompt (str): The password prompt that should be printed Returns: The password as string """ import mysqlsh if print_password_rules: print( f"When specifying the {password_caption} password, please use:\n" " - a minimum of 8 characters\n - one uppercase letter\n" " - one lowercase letter\n - one number\n - one special char") # Loop until a valid password is given while True: password = mysqlsh.globals.shell.prompt( f"Please enter the {password_caption} password: ", {'defaultValue': '', 'type': 'password'}).strip() if password == "": return "" if validate_mysql_password(password): break else: print( "The given password does not comply to the password rules. " "Please try again.\n") i = 0 while i < 2: password_2 = mysqlsh.globals.shell.prompt( f"Please confirm the {password_caption} password: ", {'defaultValue': '', 'type': 'password'}) if password_2 == "": return "" if password == password_2: break else: print( "The given passwords do not match. Please try again.\n") i += 1 if i >= 2: return "" else: return password @plugin_function('mds.list.dbSystemShapes', shell=True, cli=True, web=True) def list_db_system_shapes(**kwargs): """Lists Shapes available for MySQL DB Systems Lists all shapes of a given compartment. Args: **kwargs: Optional parameters Keyword Args: is_supported_for (str): Either DBSYSTEM (default), HEATWAVECLUSTER or "DBSYSTEM, HEATWAVECLUSTER" availability_domain (str): The name of the availability_domain to use compartment_id (str): OCID of the parent compartment. config (object): An OCI config object or None. config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If set to true exceptions are raised return_formatted (bool): If set to true, a list object is returned. return_python_object (bool): Used for internal plugin calls Returns: A list of DB Systems Shapes """ is_supported_for = kwargs.get("is_supported_for", "DBSYSTEM") availability_domain = kwargs.get("availability_domain") compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) return_formatted = kwargs.get("return_formatted", interactive) return_python_object = kwargs.get("return_python_object", False) import oci.mysql # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) support_list = [] if 'DBSYSTEM' in is_supported_for: support_list.append('DBSYSTEM') if 'HEATWAVECLUSTER' in is_supported_for: support_list.append('HEATWAVECLUSTER') # Initialize the DbSystem client mds_client = core.get_oci_mds_client(config=config) # List the DbSystems of the current compartment data = mds_client.list_shapes(compartment_id=compartment_id, is_supported_for=support_list, availability_domain=availability_domain).data return core.return_oci_object( oci_object=data, return_python_object=return_python_object, return_formatted=return_formatted, format_function=format_mysql_shapes) except oci.exceptions.ServiceError as e: if raise_exceptions: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') except (ValueError, oci.exceptions.ClientError) as e: if raise_exceptions: raise print(f'ERROR: {e}') @plugin_function('mds.get.dbSystemShape') def get_db_system_shape(**kwargs): """Gets a certain shape specified by name The shape is specific for the given compartment and availability_domain Args: **kwargs: Additional options Keyword Args: is_supported_for (str): Either DBSYSTEM (default), HEATWAVECLUSTER or "DBSYSTEM, HEATWAVECLUSTER" availability_domain (str): The name of the availability_domain to use compartment_id (str): OCID of the parent compartment. config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised return_formatted (bool): If true a human readable string is returned return_python_object (bool): Used for internal plugin calls Returns: An shape object or None """ is_supported_for = kwargs.get("is_supported_for", "DBSYSTEM") availability_domain = kwargs.get("availability_domain") compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) return_formatted = kwargs.get("return_formatted", interactive) return_python_object = kwargs.get("return_python_object", False) try: # Get the active config and compartment config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) # Get the list of available shapes shapes = list_db_system_shapes( is_supported_for=is_supported_for, availability_domain=availability_domain, compartment_id=compartment_id, config=config, interactive=interactive, raise_exceptions=True, return_python_object=True) if not shapes: raise Exception("No shapes found.") # Let the user choose from the list shape = core.prompt_for_list_item( item_list=shapes, prompt_caption="Please enter the name or index of the shape: ", item_name_property="name", print_list=True) return core.return_oci_object( oci_object=shape, return_formatted=return_formatted, return_python_object=return_python_object, format_function=format_mysql_shapes) except Exception as e: if raise_exceptions: raise print(f'ERROR: {str(e)}') @plugin_function('mds.list.dbSystems', shell=True, cli=True, web=True) def list_db_systems(**kwargs): """Lists MySQL DB Systems Lists all DB Systems of a given compartment. Args: **kwargs: Optional parameters Keyword Args: compartment_id (str): OCID of the parent compartment. config (object): An OCI config object or None. config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If set to true exceptions are raised return_formatted (bool): If set to true, a list object is returned. return_python_object (bool): Used for internal plugin calls Returns: A list of DB Systems """ compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) return_formatted = kwargs.get("return_formatted", interactive) return_python_object = kwargs.get("return_python_object", False) import oci.mysql # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) current_db_system_id = configuration.get_current_db_system_id( config=config) mds_client = core.get_oci_mds_client(config=config) # Get the list of shapes, cSpell:ignore ANALYTICSCLUSTER all_shapes = mds_client.list_shapes(compartment_id=compartment_id, is_supported_for=['DBSYSTEM','HEATWAVECLUSTER']).data hw_shapes = [s.name for s in all_shapes if "HEATWAVECLUSTER" in s.is_supported_for] # Support for "ANALYTICSCLUSTER" has been removed from the SDK analytics_shapes = [] #[s.name for s in all_shapes if "ANALYTICSCLUSTER" in s.is_supported_for] # Initialize the DbSystem client db_sys = core.get_oci_db_system_client(config=config) # List the DbSystems of the current compartment data = db_sys.list_db_systems(compartment_id=compartment_id).data # Filter out all deleted db_systems data = [d for d in data if d.lifecycle_state != "DELETED"] # Add supported HW flags for d in data: setattr(d, "is_supported_for_hw_cluster", d.shape_name in hw_shapes) d.swagger_types["is_supported_for_hw_cluster"] = "bool" setattr(d, "is_supported_for_analytics_cluster", d.shape_name in analytics_shapes) d.swagger_types["is_supported_for_analytics_cluster"] = "bool" return core.return_oci_object( oci_object=data, return_python_object=return_python_object, return_formatted=return_formatted, format_function=format_db_systems, current=current_db_system_id) except oci.exceptions.ServiceError as e: if raise_exceptions: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') except (ValueError, oci.exceptions.ClientError) as e: if raise_exceptions: raise print(f'ERROR: {e}') @plugin_function('mds.get.dbSystem', shell=True, cli=True, web=True) def get_db_system(**kwargs): """Gets a DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The new name of the compartment. db_system_id (str): OCID of the DbSystem. ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised return_formatted (bool): If true a human readable string is returned return_python_object (bool): Used for internal plugin calls Returns: None """ db_system_name = kwargs.get("db_system_name") db_system_id = kwargs.get("db_system_id") ignore_current = kwargs.get("ignore_current", False) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) return_formatted = kwargs.get("return_formatted", interactive) return_python_object = kwargs.get("return_python_object", False) try: # Get the active config and compartment config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) current_db_system_id = configuration.get_current_db_system_id( config=config) if (not ignore_current and db_system_name is None and db_system_id is None and current_db_system_id): db_system_id = current_db_system_id import oci.identity import oci.util try: if db_system_id: return core.return_oci_object( oci_object=get_db_system_by_id( db_system_id=db_system_id, config=config), return_formatted=return_formatted, return_python_object=return_python_object, format_function=format_db_systems, current=current_db_system_id) # Initialize the DbSystem client db_sys = core.get_oci_db_system_client(config=config) # List the DbSystems of the current compartment db_systems = db_sys.list_db_systems( compartment_id=compartment_id).data # Filter out all deleted compartments db_systems = [u for u in db_systems if u.lifecycle_state != "DELETED"] if len(db_systems) == 0: if interactive: print("No MySQL DB Systems available in this compartment.") return return None # If a name was given, look it up in the list and return it if db_system_name is not None: for d in db_systems: if d.display_name.lower() == db_system_name.lower(): return core.return_oci_object( oci_object=get_db_system_by_id( db_system_id=d.id, config=config), return_formatted=return_formatted, return_python_object=return_python_object, format_function=format_db_systems, current=current_db_system_id) # If the db_systems was not found by id or name, return None if # not in interactive mode if not interactive: return None # Let the user choose from the list db_system = core.prompt_for_list_item( item_list=db_systems, prompt_caption=("Please enter the name or index " "of the MySQL DB System: "), item_name_property="display_name", given_value=db_system_name, print_list=True) if db_system: return core.return_oci_object( oci_object=get_db_system_by_id( db_system_id=db_system.id, config=config), return_formatted=return_formatted, return_python_object=return_python_object, format_function=format_db_systems, current=current_db_system_id) except oci.exceptions.ServiceError as e: if raise_exceptions: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') except Exception as e: if raise_exceptions: raise print(f'ERROR: {e}') @plugin_function('mds.get.dbSystemId', shell=True, cli=True, web=True) def get_db_system_id(**kwargs): """Gets information about the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The new name of the compartment. ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the compartment. config (object): An OCI config object or None. config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ db_system_name = kwargs.get("db_system_name") ignore_current = kwargs.get("ignore_current", False) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) db_system = get_db_system( db_system_name=db_system_name, ignore_current=ignore_current, compartment_id=compartment_id, config=config, config_profile=config_profile, interactive=interactive, raise_exceptions=raise_exceptions, return_formatted=False, return_python_object=True) return None if db_system is None else db_system.id @plugin_function('mds.update.dbSystem', shell=True, cli=True, web=True) def update_db_system(**kwargs): """Updates the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. ignore_current (bool): Whether to not default to the current bastion. new_name (str): The new name new_description (str): The new description new_freeform_tags (str): The new freeform_tags formatted as string compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ db_system_name = kwargs.get("db_system_name") db_system_id = kwargs.get("db_system_id") ignore_current = kwargs.get("ignore_current", False) new_name = kwargs.get("new_name") new_description = kwargs.get("new_description") new_freeform_tags = kwargs.get("new_freeform_tags") compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) current_db_system_id = configuration.get_current_db_system_id( config=config) if (not ignore_current and db_system_name is None and db_system_id is None and current_db_system_id): db_system_id = current_db_system_id import oci.identity import oci.mysql import mysqlsh import json try: # Get the db_system based on input params db_system = get_db_system( db_system_name=db_system_name, db_system_id=db_system_id, compartment_id=compartment_id, config=config, interactive=interactive, raise_exceptions=True, return_python_object=True) if db_system is None: if db_system_name or db_system_id: raise ValueError("DB System not found.") else: raise Exception("Cancelling operation.") if not new_name and interactive: # Prompt the user for the new values new_name = mysqlsh.globals.shell.prompt( f"Please enter a new name for the DbSystem " f"[{db_system.display_name}]: ", {'defaultValue': db_system.display_name}).strip() if not new_description and interactive: new_description = mysqlsh.globals.shell.prompt( "Please enter a new description for the DbSystem " "[current description]: ", {'defaultValue': db_system.description if db_system.description is not None else ''}).strip() if not new_freeform_tags and interactive: new_freeform_tags = mysqlsh.globals.shell.prompt( f"Please enter new freeform_tags for the DbSystem " f"[{str(db_system.freeform_tags)}]: ", {'defaultValue': json.dumps(db_system.freeform_tags) if db_system.freeform_tags is not None else ''}).strip() if new_freeform_tags and isinstance(new_freeform_tags, str): new_freeform_tags = json.loads(new_freeform_tags) if not new_name and not new_freeform_tags and not new_freeform_tags: raise ValueError("Nothing to update.") # Initialize the DbSystem client db_sys = core.get_oci_db_system_client(config=config) update_details = oci.mysql.models.UpdateDbSystemDetails( display_name=new_name, description=new_description, freeform_tags=new_freeform_tags ) db_sys.update_db_system(db_system.id, update_details) if interactive: print(f"DbSystem {db_system.display_name} is being updated.") except oci.exceptions.ServiceError as e: if raise_exceptions: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') except (ValueError, oci.exceptions.ClientError) as e: if raise_exceptions: raise print(f'ERROR: {e}') @plugin_function('mds.create.dbSystem', shell=True, cli=True, web=True) def create_db_system(**kwargs): """Creates a DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The new name of the DB System. description (str): The new description of the DB System. availability_domain (str): The name of the availability_domain shape (str): The compute shape name to use for the instance subnet_id (str): The OCID of the subnet to use configuration_id (str): The OCID of the MySQL configuration data_storage_size_in_gbs (int): The data storage size in gigabytes mysql_version (str): The MySQL version admin_username (str): The name of the administrator user account admin_password (str): The password of the administrator account private_key_file_path (str): The file path to an SSH private key par_url (str): The PAR url used for initial data import perform_cleanup_after_import (bool): Whether the bucket and PARs should be kept or deleted if an import took place source_mysql_uri (str): The MySQL Connection URI if data should be imported from an existing MySQL Server instance source_mysql_password (str): The password to use when data should be imported from an existing MySQL Server instance source_local_dump_dir (str): The path to a local directory that contains a dump source_bucket (str): The name of the source bucket that contains a dump host_image_id (str): OCID of the host image to use for this Instance. Private API only. defined_tags (dict): The defined_tags of the dynamic group. freeform_tags (dict): The freeform_tags of the dynamic group compartment_id (str): The OCID of the compartment config (object): An OCI config object or None. interactive (bool): Ask the user for input if needed return_object (bool): Whether to return the object when created Returns: None or the new DB System object if return_object is set to true """ db_system_name = kwargs.get("db_system_name") description = kwargs.get("description") availability_domain = kwargs.get("availability_domain") shape = kwargs.get("shape") subnet_id = kwargs.get("subnet_id") configuration_id = kwargs.get("configuration_id") data_storage_size_in_gbs = kwargs.get("data_storage_size_in_gbs") mysql_version = kwargs.get("mysql_version") admin_username = kwargs.get("admin_username") admin_password = kwargs.get("admin_password") private_key_file_path = kwargs.get( "private_key_file_path", "~/.ssh/id_rsa") par_url = kwargs.get("par_url") perform_cleanup_after_import = kwargs.get( "perform_cleanup_after_import") source_mysql_uri = kwargs.get("source_mysql_uri") source_mysql_password = kwargs.get("source_mysql_password") source_local_dump_dir = kwargs.get("source_local_dump_dir") source_bucket = kwargs.get("source_bucket") #host_image_id = kwargs.get("host_image_id") defined_tags = kwargs.get("defined_tags") # Conversion from Shell Dict type if defined_tags: defined_tags = dict(defined_tags) freeform_tags = kwargs.get("freeform_tags") # Conversion from Shell Dict type if freeform_tags: freeform_tags = dict(freeform_tags) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") interactive = kwargs.get("interactive", True) return_object = kwargs.get("return_object", False) try: # Get the active config and compartment config = configuration.get_current_config(config=config) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) import oci.mysql from pathlib import Path import mysqlsh from mds_plugin import compartment, compute, network, object_store import datetime import time # Set the import_source_type to 0 to default to a clean new DB System import_source_type = 0 # Check if source_* parameters are given and if so, set the correct # import_source_type if source_mysql_uri is not None: # Import from an existing MySQL Server instance import_source_type = 1 elif source_local_dump_dir is not None: # Import from a local data dir import_source_type = 2 elif source_bucket is not None: # Import from an existing bucket import_source_type = 3 # If the user did not specify a par_url, or other source paremeter, # let him choose if he wants to import data from a given source if interactive and import_source_type == 0 and par_url is None: print("Choose one of the following options of how to create the " "MySQL DB System:\n") import_sources = [ "Create a clean MySQL DB System", ("Create a MySQL DB System from an existing MySQL Server " "instance"), "Create a MySQL DB System from a local dump", ("Create a MySQL DB System from a dump stored on OCI " "Object Storage") ] import_source = core.prompt_for_list_item( item_list=import_sources, prompt_caption=("Please enter the index of an option listed " "above: "), prompt_default_value='', print_list=True) if import_source == "": print("Operation cancelled.") return import_source_type = import_sources.index(import_source) # Get a name if not db_system_name and interactive: db_system_name = core.prompt( "Please enter the name for the new DB System: ").strip() if not db_system_name: raise Exception("No name given. " "Operation cancelled.") # Get a description if not description and interactive: description = core.prompt( "Please enter a description for the new DB System: ").strip() # Get an admin_username if not admin_username and interactive: admin_username = core.prompt( "MySQL Administrator account name [admin]: ", {'defaultValue': 'admin'}).strip() if not admin_username: raise Exception("No admin username given. " "Operation cancelled.") # Get an admin_password if not admin_password and interactive: admin_password = get_validated_mysql_password( password_caption="MySQL Administrator account") if not admin_password: raise Exception("No admin password given. " "Operation cancelled.") # Get data_storage_size_in_gbs if not data_storage_size_in_gbs and interactive: data_storage_size_in_gbs = core.prompt( "Please enter the amount of data storage size in gigabytes " "with a minimum of 50 GB [50]: ", {'defaultValue': '50'}).strip() try: data_storage_size_in_gbs = int(data_storage_size_in_gbs) except ValueError: ValueError("Please enter a number for data storage size.\n") if not data_storage_size_in_gbs: raise Exception("No data storage size given. " "Operation cancelled.") # Get the availability_domain name availability_domain_obj = compartment.get_availability_domain( random_selection=not interactive, compartment_id=compartment_id, availability_domain=availability_domain, config=config, interactive=interactive, return_python_object=True) if not availability_domain_obj: raise Exception("No availability domain selected. " "Operation cancelled.") availability_domain = availability_domain_obj.name if interactive: print(f"Using availability domain {availability_domain}.") # Get the shapes shape_id = compute.get_shape_name( shape_name=shape, limit_shapes_to=[ "VM.Standard.E2.1", "VM.Standard.E2.2", "VM.Standard.E2.4", "VM.Standard.E2.8"], compartment_id=compartment_id, availability_domain=availability_domain, config=config, interactive=interactive) if shape_id is None or shape_id == "": print("Compute Shape not set or found. Operation cancelled.") return if interactive: print(f"Using shape {shape_id}.") # Get private subnet subnet = network.get_subnet( subnet_id=subnet_id, public_subnet=False, compartment_id=compartment_id, config=config, interactive=interactive, availability_domain=availability_domain) if subnet is None: print("Operation cancelled.") return if interactive: print(f"Using subnet {subnet.display_name}.") # Get mysql_version mysql_version = get_mysql_version(compartment_id=compartment_id, config=config) if mysql_version is None: print("Operation cancelled.") return print(f"Using MySQL version {mysql_version}.") # Get mysql_configuration mysql_configuration = get_db_system_configuration( configuration_id=configuration_id, shape=shape_id, availability_domain=availability_domain, compartment_id=compartment_id, config=config, return_python_object=True) if mysql_configuration is None: print("Operation cancelled.") return print(f"Using MySQL configuration {mysql_configuration.display_name}.") # TODO Check Limits # limits.list_limit_values(config["tenancy"], "mysql").data # limits.get_resource_availability( # service_name="mysql", limit_name="vm-standard-e2-4-count", # compartment_id=config["tenancy"], # availability_domain="fblN:US-ASHBURN-AD-1").data # limits.get_resource_availability( # service_name="compute", limit_name="standard-e2-core-ad-count", # compartment_id=config["tenancy"], # availability_domain="fblN:US-ASHBURN-AD-1").data # If requested, prepare import if import_source_type > 0: # If a bucket needs to be created, define a name for it if import_source_type == 1 or import_source_type == 2: # Take all alphanumeric chars from the DB System name # to create the bucket_name bucket_name = ( f"{''.join(e for e in db_system_name if e.isalnum())}_import_" f"{datetime.datetime.now():%Y%m%d%H%M%S}") print(f"\nCreating bucket {bucket_name}...") bucket = object_store.create_bucket( bucket_name=bucket_name, compartment_id=compartment_id, config=config, return_object=True) if bucket is None: print("Cancelling operation") return if perform_cleanup_after_import is None: perform_cleanup_after_import = True # Create a MySQL DB System from an existing MySQL Server instance if import_source_type == 1: # Start the dump process if not util.dump_to_bucket(bucket_name=bucket.name, connection_uri=source_mysql_uri, connection_password=source_mysql_password, create_bucket_if_not_exists=True, object_name_prefix="", interactive=interactive, return_true_on_success=True): print(f"Could not dump the given instance to the object " f"store bucket {bucket.name}") return # Create a MySQL DB System from local dir elif import_source_type == 2: if interactive and source_local_dump_dir is None: source_local_dump_dir = mysqlsh.globals.shell.prompt( "Please specify the directory path that contains the " "dump: ", {'defaultValue': ''}).strip() if source_local_dump_dir == "": print("Operation cancelled.") return elif source_local_dump_dir is None: print("No directory path given. Operation cancelled.") return # Upload the files from the given directory to the bucket file_count = object_store.create_bucket_objects_from_local_dir( local_dir_path=source_local_dump_dir, bucket_name=bucket.name, object_name_prefix="", compartment_id=compartment_id, config=config, interactive=False) if file_count is None: print("Cancelling operation") return elif import_source_type == 3: # Create a MySQL DB System from a bucket bucket = object_store.get_bucket( bucket_name=source_bucket, compartment_id=compartment_id, config=config) if bucket is None: print("Cancelling operation") return bucket_name = bucket.name if perform_cleanup_after_import is None: perform_cleanup_after_import = False # Create PAR for import manifest and progress files par, progress_par = util.create_bucket_import_pars( object_name_prefix="", bucket_name=bucket.name, db_system_name=db_system_name, compartment_id=compartment_id, config=config) if par is None or progress_par is None: return # Build URLs par_url_prefix = object_store.get_par_url_prefix(config=config) par_url = par_url_prefix + par.access_uri # progress_par_url = par_url_prefix + progress_par.access_uri # Once the API supports the new PAR based import, build the # import_details using the given par_url # if par_url: # import urllib.parse # import_details = oci.mysql.models.\ # CreateDbSystemSourceImportFromUrlDetails( # source_type=oci.mysql.models. # CreateDbSystemSourceImportFromUrlDetails. # SOURCE_TYPE_IMPORTURL, # source_url=(f'{par_url}?progressPar=' # f'{urllib.parse.quote(progress_par_url)}')) db_system_details = oci.mysql.models.CreateDbSystemDetails( description=description, admin_username=admin_username, admin_password=admin_password, compartment_id=compartment_id, configuration_id=mysql_configuration.id, data_storage_size_in_gbs=data_storage_size_in_gbs, display_name=db_system_name, mysql_version=mysql_version, shape_name=shape_id, availability_domain=availability_domain, subnet_id=subnet.id, defined_tags=defined_tags, freeform_tags=freeform_tags # host_image_id=host_image_id # source=import_details ) # Get DbSystem Client db_sys = core.get_oci_db_system_client(config=config) # Create DB System new_db_system = db_sys.create_db_system(db_system_details).data # If there was a PAR URL given, wait till the system becomes # ACTIVE and then perform the clean up work if par_url is not None: print("Waiting for MySQL DB System to become active.\n" "This can take up to 20 minutes or more...", end="") # Wait until the lifecycle_state == ACTIVE, 20 minutes max cycles = 0 while cycles < 240: db_system = db_sys.get_db_system(new_db_system.id).data if db_system.lifecycle_state == "ACTIVE" or \ db_system.lifecycle_state == "FAILED": break else: time.sleep(10) print(".", end="") cycles += 1 print("") # Until the API is ready to directly import at deployment time, # also start the import from here if db_system.lifecycle_state == "ACTIVE": util.import_from_bucket( bucket_name=bucket_name, db_system_id=new_db_system.id, db_system_name=db_system_name, object_name_prefix="", admin_username=admin_username, admin_password=admin_password, private_key_file_path=private_key_file_path, perform_cleanup=perform_cleanup_after_import, compartment_id=compartment_id, config=config, interactive=False ) else: if return_object: return new_db_system else: if new_db_system.lifecycle_state == "CREATING": print(f"\nMySQL DB System {db_system_name} is being created.\n" f"Use mds.ls() to check it's provisioning state.\n") else: print(f"\nThe creation of the MySQL DB System {db_system_name} " "failed.\n") except oci.exceptions.ServiceError as e: if not interactive: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') return except (ValueError, oci.exceptions.ClientError) as e: if not interactive: raise print(f'ERROR: {e}') return @plugin_function('mds.delete.dbSystem', shell=True, cli=True, web=True) def delete_db_system(**kwargs): """Updates the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ db_system_name = kwargs.get("db_system_name") db_system_id = kwargs.get("db_system_id") await_completion = kwargs.get("await_completion") ignore_current = kwargs.get("ignore_current", False) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) # Get the active config and compartment try: import oci.mysql import mysqlsh db_system = get_db_system( db_system_name=db_system_name, db_system_id=db_system_id, compartment_id=compartment_id, config=config, interactive=interactive, raise_exceptions=raise_exceptions, ignore_current=ignore_current, return_python_object=True) if db_system is None: if db_system_name or db_system_id: raise ValueError("DB System not found.") else: raise Exception("Cancelling operation.") if interactive: # Prompt the user for specifying a compartment prompt = mysqlsh.globals.shell.prompt( f"Are you sure you want to delete the MySQL DB System " f"{db_system.display_name} [yes/NO]: ", {'defaultValue': 'no'}).strip().lower() if prompt != "yes": print("Deletion aborted.\n") return # Get DbSystem Client db_sys = core.get_oci_db_system_client(config=config) # Delete the DB System work_request_id = db_sys.delete_db_system(db_system.id).headers["opc-work-request-id"] # If the function should wait till the bastion reaches the correct # lifecycle state if await_completion: await_lifecycle_state( db_system.id, "DELETED", "complete the deletion process", config, interactive, work_request_id) elif interactive: print(f"MySQL DB System '{db_system.display_name}' is being " "deleted.") except oci.exceptions.ServiceError as e: if interactive: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') return except Exception as e: if raise_exceptions: raise print(f'ERROR: {e}') @plugin_function('mds.stop.dbSystem', shell=True, cli=True, web=True) def stop_db_system(**kwargs): """Stops the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ change_lifecycle_state(**kwargs, action=DB_SYSTEM_ACTION_STOP) @plugin_function('mds.start.dbSystem', shell=True, cli=True, web=True) def start_db_system(**kwargs): """Starts the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ change_lifecycle_state(**kwargs, action=DB_SYSTEM_ACTION_START) @plugin_function('mds.restart.dbSystem', shell=True, cli=True, web=True) def restart_db_system(**kwargs): """Restarts the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ change_lifecycle_state(**kwargs, action=DB_SYSTEM_ACTION_RESTART) @plugin_function('mds.stop.heatWaveCluster', shell=True, cli=True, web=True) def stop_hw_cluster(**kwargs): """Stops the HeatWave cluster with the given DBSystem id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ change_lifecycle_state(**kwargs, action=HW_CLUSTER_ACTION_STOP) @plugin_function('mds.start.heatWaveCluster', shell=True, cli=True, web=True) def start_hw_cluster(**kwargs): """Starts the HeatWave cluster with the given DBSystem id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ change_lifecycle_state(**kwargs, action=HW_CLUSTER_ACTION_START) @plugin_function('mds.restart.heatWaveCluster', shell=True, cli=True, web=True) def restart_hw_cluster(**kwargs): """Restarts the HeatWave cluster with the given DBSystem id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ change_lifecycle_state(**kwargs, action=HW_CLUSTER_ACTION_RESTART) def change_lifecycle_state(**kwargs): """Starts or stops the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised action (int): The action to execute Returns: None """ db_system_name = kwargs.get("db_system_name") db_system_id = kwargs.get("db_system_id") await_completion = kwargs.get("await_completion") ignore_current = kwargs.get("ignore_current", False) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) action = kwargs.get("action") if action == DB_SYSTEM_ACTION_START or action == HW_CLUSTER_ACTION_START: action_name = "start" action_state = "ACTIVE" elif action == DB_SYSTEM_ACTION_STOP or action == HW_CLUSTER_ACTION_STOP: action_name = "stop" action_state = "INACTIVE" elif action == DB_SYSTEM_ACTION_RESTART or action == HW_CLUSTER_ACTION_RESTART: action_name = "restart" action_state = "ACTIVE" else: raise ValueError("Unknown action given.") db_system_action = ( action == DB_SYSTEM_ACTION_START or action == DB_SYSTEM_ACTION_STOP or action == DB_SYSTEM_ACTION_RESTART ) action_obj = "DB System" if db_system_action else "HeatWave Cluster" # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) # Get the active config and compartment try: import oci.mysql import mysqlsh db_system = get_db_system( db_system_name=db_system_name, db_system_id=db_system_id, compartment_id=compartment_id, config=config, interactive=interactive, raise_exceptions=raise_exceptions, ignore_current=ignore_current, return_python_object=True) if db_system is None: if db_system_name or db_system_id: raise ValueError("DB System not found.") else: raise Exception("Cancelling operation.") else: db_system_id = db_system.id if interactive: # Prompt the user for specifying a compartment prompt = mysqlsh.globals.shell.prompt( f"Are you sure you want to {action_name} the {action_obj} " f"{db_system.display_name} [yes/NO]: ", {'defaultValue': 'no'}).strip().lower() if prompt != "yes": print("Operation cancelled.\n") return # Get DbSystem Client db_sys = core.get_oci_db_system_client(config=config) work_request_id = None if action == DB_SYSTEM_ACTION_STOP: # Stop the DB System work_request_id = db_sys.stop_db_system( db_system_id, oci.mysql.models.StopDbSystemDetails( shutdown_type="IMMEDIATE" )).headers["opc-work-request-id"] elif action == DB_SYSTEM_ACTION_START: # Start the DB System work_request_id = db_sys.start_db_system(db_system_id).headers["opc-work-request-id"] elif action == DB_SYSTEM_ACTION_RESTART: # Restart the DB System work_request_id = db_sys.restart_db_system( db_system_id, oci.mysql.models.RestartDbSystemDetails( shutdown_type="IMMEDIATE" )) elif action == HW_CLUSTER_ACTION_STOP: # Stop the HW Cluster work_request_id = db_sys.stop_heat_wave_cluster(db_system_id).headers["opc-work-request-id"] elif action == HW_CLUSTER_ACTION_START: # Start the HW Cluster work_request_id = db_sys.start_heat_wave_cluster(db_system_id).headers["opc-work-request-id"] elif action == HW_CLUSTER_ACTION_RESTART: # Restart the HW Cluster work_request_id = db_sys.restart_heat_wave_cluster(db_system_id).headers["opc-work-request-id"] # If the function should wait till the bastion reaches the correct # lifecycle state if await_completion: if db_system_action: await_lifecycle_state( db_system_id, action_state, action_name, config, interactive, work_request_id) else: await_hw_cluster_lifecycle_state( db_system_id, action_state, action_name, config, interactive, work_request_id) elif interactive: print(f"MySQL {action_obj} '{db_system.display_name}' is being " f"{action_name}{'p' if action_name == 'stop' else ''}ed.") except oci.exceptions.ServiceError as e: if interactive: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') return except Exception as e: if raise_exceptions: raise print(f'ERROR: {e}') def await_lifecycle_state(db_system_id, action_state, action_name, config, interactive, work_request_id): """Waits of the db_system to reach the desired lifecycle state Args: db_system_id (str): OCID of the DbSystem. action_state (str): The lifecycle state to reach action_name (str): The name of the action to be performed config (dict): An OCI config object or None interactive (bool): Indicates whether to execute in interactive mode request_id (bool): The request_id of the action Returns: None """ import time # Get DbSystem Client db_sys = core.get_oci_db_system_client(config=config) # Get WorkRequest Client req_client = core.get_oci_work_requests_client(config=config) # Wait for the lifecycle to reach desired state cycles = 0 while cycles < 120: db_system = db_sys.get_db_system( db_system_id=db_system_id).data if db_system.lifecycle_state == action_state: break else: if interactive: s = "." * (cycles + 1) try: if work_request_id: req = req_client.get_work_request(work_request_id=work_request_id).data s = f" {req.percent_complete:.0f}% completed." except: pass print(f'Waiting for DB System to {action_name}...{s}', end='\r') time.sleep(5) cycles += 1 if interactive: print("") if db_system.lifecycle_state != action_state: raise Exception("The DB System did not reach the correct " "state within 10 minutes.") if interactive: print(f"DB System '{db_system.display_name}' did " f"{action_name} successfully.") def await_hw_cluster_lifecycle_state(db_system_id, action_state, action_name, config, interactive, work_request_id): """Waits of the db_system to reach the desired lifecycle state Args: db_system_id (str): OCID of the DbSystem. action_state (str): The lifecycle state to reach action_name (str): The name of the action to be performed config (dict): An OCI config object or None interactive (bool): Indicates whether to execute in interactive mode Returns: None """ import time # Get DbSystem Client db_sys = core.get_oci_db_system_client(config=config) # Get WorkRequest Client req_client = core.get_oci_work_requests_client(config=config) # Wait for the lifecycle to reach desired state cycles = 0 while cycles < 240: db_system = db_sys.get_db_system( db_system_id=db_system_id).data if db_system.heat_wave_cluster and db_system.heat_wave_cluster.lifecycle_state == action_state: break else: if interactive: s = "." * (cycles + 1) try: if work_request_id: req = req_client.get_work_request(work_request_id=work_request_id).data s = f" {req.percent_complete:.0f}% completed." except: pass print(f'Waiting for HeatWave Cluster to {action_name}...{s}') time.sleep(5) cycles += 1 if interactive: print("") if (not db_system.heat_wave_cluster) or db_system.heat_wave_cluster.lifecycle_state != action_state: raise Exception("The HeatWave Cluster did not reach the correct " "state within 20 minutes.") if interactive: print(f"The HeatWave Cluster of DB System '{db_system.display_name}' did " f"{action_name} successfully.") @plugin_function('mds.create.heatWaveCluster', shell=True, cli=True, web=True) def create_hw_cluster(**kwargs): """Adds a HeatWave cluster to the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. ignore_current (bool): Whether to not default to the current DB System. cluster_size (int): The size of the cluster shape_name (str): The name of the shape to use await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state compartment_id (str): OCID of the parent compartment. config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ db_system_name = kwargs.get("db_system_name") db_system_id = kwargs.get("db_system_id") ignore_current = kwargs.get("ignore_current", False) cluster_size = kwargs.get("cluster_size") shape_name = kwargs.get("shape_name") await_completion = kwargs.get("await_completion", False) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) current_db_system_id = configuration.get_current_db_system_id( config=config) if (not ignore_current and db_system_name is None and db_system_id is None and current_db_system_id): db_system_id = current_db_system_id import oci.identity import oci.mysql import mysqlsh import json try: # Get the db_system based on input params db_system = get_db_system( db_system_name=db_system_name, db_system_id=db_system_id, compartment_id=compartment_id, config=config, interactive=interactive, raise_exceptions=True, return_python_object=True) if db_system is None: if db_system_name or db_system_id: raise ValueError("DB System not found.") else: raise Exception("Cancelling operation.") if not cluster_size and interactive: # Prompt the user for the new values cluster_size = mysqlsh.globals.shell.prompt( f"Please enter the number of nodes for the HeatWave cluster " f"(1 - 64): ", {'defaultValue': '1'}).strip() if cluster_size is None: raise ValueError("The cluster_size was not specified.") if cluster_size == "": cluster_size = '1' try: cluster_size = int(cluster_size) except: raise ValueError(f"'{cluster_size}' is not a valid number.") if cluster_size < 1 or cluster_size > 64: raise ValueError(f"The cluster size must be between 1 and 64. A size of {cluster_size} was given.") if not shape_name and interactive: shape = get_db_system_shape( is_supported_for="HEATWAVECLUSTER", compartment_id=db_system.compartment_id, config=config, config_profile=config_profile, interactive=True, raise_exceptions=True, return_python_object=True) if shape: shape_name = shape.name if not shape_name: raise ValueError("No shape name given.") # Initialize the DbSystem client db_sys = core.get_oci_db_system_client(config=config) details = oci.mysql.models.AddHeatWaveClusterDetails( cluster_size=cluster_size, shape_name=shape_name, ) work_request_id = db_sys.add_heat_wave_cluster( db_system.id, add_heat_wave_cluster_details=details).headers["opc-work-request-id"] if await_completion: await_hw_cluster_lifecycle_state(db_system_id=db_system.id, action_state='ACTIVE', action_name="start", config=config, interactive=interactive, work_request_id=work_request_id) elif interactive: print(f"The HeatWave Cluster of the MySQL DB System '{db_system.display_name}' is being " "created.") except oci.exceptions.ServiceError as e: if raise_exceptions: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') except (ValueError, oci.exceptions.ClientError) as e: if raise_exceptions: raise print(f'ERROR: {e}') @plugin_function('mds.update.heatWaveCluster', shell=True, cli=True, web=True) def update_hw_cluster(**kwargs): """Update the HeatWave cluster for a DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. ignore_current (bool): Whether to not default to the current DB System. cluster_size (int): The size of the cluster shape_name (str): The name of the shape to use await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state compartment_id (str): OCID of the parent compartment. config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ db_system_name = kwargs.get("db_system_name") db_system_id = kwargs.get("db_system_id") ignore_current = kwargs.get("ignore_current", False) cluster_size = kwargs.get("cluster_size") shape_name = kwargs.get("shape_name") await_completion = kwargs.get("await_completion", False) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) current_db_system_id = configuration.get_current_db_system_id( config=config) if (not ignore_current and db_system_name is None and db_system_id is None and current_db_system_id): db_system_id = current_db_system_id import oci.identity import oci.mysql import mysqlsh import json try: # Get the db_system based on input params db_system = get_db_system( db_system_name=db_system_name, db_system_id=db_system_id, compartment_id=compartment_id, config=config, interactive=interactive, raise_exceptions=True, return_python_object=True) if db_system is None: if db_system_name or db_system_id: raise ValueError("DB System not found.") else: raise Exception("Cancelling operation.") if not cluster_size and interactive: # Prompt the user for the new values cluster_size = mysqlsh.globals.shell.prompt( f"Please enter the number of nodes for the HeatWave cluster " f"(1 - 64): ", {'defaultValue': '1'}).strip() if cluster_size is None: raise ValueError("The cluster_size was not specified.") if cluster_size == "": cluster_size = '1' try: cluster_size = int(cluster_size) except: raise ValueError(f"'{cluster_size}' is not a valid number.") if cluster_size < 1 or cluster_size > 64: raise ValueError(f"The cluster size must be between 1 and 64. A size of {cluster_size} was given.") if not shape_name and interactive: shape = get_db_system_shape( is_supported_for="HEATWAVECLUSTER", compartment_id=db_system.compartment_id, config=config, config_profile=config_profile, interactive=True, raise_exceptions=True, return_python_object=True) if shape: shape_name = shape.name if not shape_name: raise ValueError("No shape name given.") # Initialize the DbSystem client db_sys = core.get_oci_db_system_client(config=config) details = oci.mysql.models.UpdateHeatWaveClusterDetails( cluster_size=cluster_size, shape_name=shape_name, ) work_request_id = db_sys.update_heat_wave_cluster( db_system.id, update_heat_wave_cluster_details=details).headers["opc-work-request-id"] if await_completion: await_hw_cluster_lifecycle_state(db_system_id=db_system.id, action_state='ACTIVE', action_name="rescale", config=config, interactive=interactive, work_request_id=work_request_id) elif interactive: print(f"The HeatWave Cluster of the MySQL DB System '{db_system.display_name}' is being " "rescaled.") except oci.exceptions.ServiceError as e: if raise_exceptions: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') except (ValueError, oci.exceptions.ClientError) as e: if raise_exceptions: raise print(f'ERROR: {e}') @plugin_function('mds.delete.heatWaveCluster', shell=True, cli=True, web=True) def delete_hw_cluster(**kwargs): """Deletes the DbSystem with the given id If no id is given, it will prompt the user for the id. Args: **kwargs: Optional parameters Keyword Args: db_system_name (str): The name of the DB System. db_system_id (str): OCID of the DbSystem. await_completion (bool): Whether to wait till the DbSystem reaches the desired lifecycle state ignore_current (bool): Whether to not default to the current bastion. compartment_id (str): OCID of the parent compartment config (dict): An OCI config object or None config_profile (str): The name of an OCI config profile interactive (bool): Indicates whether to execute in interactive mode raise_exceptions (bool): If true exceptions are raised Returns: None """ db_system_name = kwargs.get("db_system_name") db_system_id = kwargs.get("db_system_id") await_completion = kwargs.get("await_completion") ignore_current = kwargs.get("ignore_current", False) compartment_id = kwargs.get("compartment_id") config = kwargs.get("config") config_profile = kwargs.get("config_profile") interactive = kwargs.get("interactive", core.get_interactive_default()) raise_exceptions = kwargs.get("raise_exceptions", not interactive) # Get the active config and compartment try: config = configuration.get_current_config( config=config, config_profile=config_profile, interactive=interactive) compartment_id = configuration.get_current_compartment_id( compartment_id=compartment_id, config=config) # Get the active config and compartment try: import oci.mysql import mysqlsh db_system = get_db_system( db_system_name=db_system_name, db_system_id=db_system_id, compartment_id=compartment_id, config=config, interactive=interactive, raise_exceptions=raise_exceptions, ignore_current=ignore_current, return_python_object=True) if db_system is None: if db_system_name or db_system_id: raise ValueError("DB System not found.") else: raise Exception("Cancelling operation.") if interactive: # Prompt the user for specifying a compartment prompt = mysqlsh.globals.shell.prompt( f"Are you sure you want to delete the HeatWave Cluster of the MySQL DB System " f"{db_system.display_name} [yes/NO]: ", {'defaultValue': 'no'}).strip().lower() if prompt != "yes": print("Deletion aborted.\n") return # Get DbSystem Client db_sys = core.get_oci_db_system_client(config=config) # Delete the HW Cluster work_request_id = db_sys.delete_heat_wave_cluster(db_system.id).headers["opc-work-request-id"] # If the function should wait till the bastion reaches the correct # lifecycle state if await_completion: await_hw_cluster_lifecycle_state( db_system.id, "DELETED", "complete the deletion process", config, interactive, work_request_id=work_request_id) elif interactive: print(f"The HeatWave Cluster of the MySQL DB System '{db_system.display_name}' is being " "deleted.") except oci.exceptions.ServiceError as e: if interactive: raise print(f'ERROR: {e.message}. (Code: {e.code}; Status: {e.status})') return except Exception as e: if raise_exceptions: raise print(f'ERROR: {e}')