style fixed

src/azure-cli/azure/cli/command_modules/rdbms/_flexible_server_util.py

@@ -13,7 +13,7 @@
 from azure.cli.core.util import CLIError
 from azure.mgmt.resource.resources.models import ResourceGroup
 from ._client_factory import resource_client_factory, cf_mysql_flexible_location_capabilities, cf_postgres_flexible_location_capabilities
-
+from .flexible_server_custom_common import firewall_rule_create_func
 logger = get_logger(__name__)
 
 DEFAULT_LOCATION_PG = 'eastus'  # For testing: 'eastus2euap'
@@ -106,8 +106,9 @@ def create_firewall_rule(db_context, cmd, resource_group_name, server_name, star
     #    firewall_client.create_or_update(resource_group_name, server_name, firewall_name , start_ip, end_ip),
     #    cmd.cli_ctx, '{} Firewall Rule Create/Update'.format(logging_name))
 
-    firewall = firewall_client.begin_create_or_update(resource_group_name, server_name, firewall_name, start_ip,
-                                                end_ip).result()
+    firewall = firewall_rule_create_func(firewall_client, resource_group_name, server_name, firewall_rule_name=firewall_name,
+                                         start_ip_address=start_ip, end_ip_address=end_ip)
+
     return firewall.name
 
 

src/azure-cli/azure/cli/command_modules/rdbms/_util.py

@@ -6,6 +6,7 @@
 from knack.log import get_logger
 from azure.cli.core.commands import AzArgumentContext
 from azure.cli.core.util import CLIError
+from azure.mgmt.rdbms import postgresql, mysql, mariadb
 from ._client_factory import cf_mariadb_firewall_rules, cf_postgres_firewall_rules, cf_mysql_firewall_rules
 
 logger = get_logger(__name__)
@@ -77,9 +78,25 @@ def create_firewall_rule(cmd, resource_group_name, server_name, start_ip, end_ip
     firewall_client = cf_postgres_firewall_rules(cmd.cli_ctx, None)
     if db_engine == 'mysql':
         firewall_client = cf_mysql_firewall_rules(cmd.cli_ctx, None)
+        parameters = mysql.models.FirewallRule(
+            name=firewall_name,
+            start_ip_address=start_ip,
+            end_ip_address=end_ip
+        )
     elif db_engine == 'mariadb':
         firewall_client = cf_mariadb_firewall_rules(cmd.cli_ctx, None)
+        parameters = mariadb.models.FirewallRule(
+            name=firewall_name,
+            start_ip_address=start_ip,
+            end_ip_address=end_ip
+        )
+    else:
+        parameters = postgresql.models.FirewallRule(
+            name=firewall_name,
+            start_ip_address=start_ip,
+            end_ip_address=end_ip
+        )
+
+    firewall = firewall_client.begin_create_or_update(resource_group_name, server_name, firewall_name, parameters)
 
-    firewall = firewall_client.begin_create_or_update(resource_group_name, server_name, firewall_name, start_ip,
-                                                end_ip).result()
     return firewall.name

src/azure-cli/azure/cli/command_modules/rdbms/custom.py

@@ -6,31 +6,27 @@
 # pylint: disable=unused-argument, line-too-long
 
 from msrestazure.azure_exceptions import CloudError
-from azure.core.exceptions import ResourceNotFoundError
 from msrestazure.tools import resource_id, is_valid_resource_id, parse_resource_id  # pylint: disable=import-error
 from knack.log import get_logger
+from azure.core.exceptions import ResourceNotFoundError
 from azure.cli.core.commands.client_factory import get_subscription_id
 from azure.cli.core.util import CLIError, sdk_no_wait
 from azure.cli.core.local_context import ALL
 from azure.mgmt.rdbms import postgresql, mysql, mariadb
 from azure.mgmt.rdbms.mysql.operations._servers_operations import ServersOperations as MySqlServersOperations
-from azure.mgmt.rdbms.mariadb.operations._servers_operations import ServersOperations as MariaDBServersOperations
+from azure.mgmt.rdbms.mysql.operations._virtual_network_rules_operations import VirtualNetworkRulesOperations as MySqlVirtualNetworkRulesOperations
+from azure.mgmt.rdbms.mysql.operations._configurations_operations import ConfigurationsOperations as MySqlConfigurationsOperations
 from azure.mgmt.rdbms.mysql.operations._firewall_rules_operations import FirewallRulesOperations as MySqlFirewallRulesOperations
+from azure.mgmt.rdbms.mariadb.operations._servers_operations import ServersOperations as MariaDBServersOperations
+from azure.mgmt.rdbms.mysql.operations._databases_operations import DatabasesOperations as MySqlDatabasesOperations
+from azure.mgmt.rdbms.mysql.operations._server_keys_operations import ServerKeysOperations as MySqlServerKeysOperations
+from azure.mgmt.rdbms.mysql.operations._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations as MySqlPrivateEndpointConnectionsOperations
 from azure.mgmt.rdbms.postgresql.operations._firewall_rules_operations import FirewallRulesOperations as PostgreSqlFirewallRulesOperations
-from azure.mgmt.rdbms.mysql.operations._virtual_network_rules_operations import VirtualNetworkRulesOperations as MySqlVirtualNetworkRulesOperations
 from azure.mgmt.rdbms.postgresql.operations._virtual_network_rules_operations import VirtualNetworkRulesOperations as PostgreSqlVirtualNetworkRulesOperations
-from azure.mgmt.rdbms.mysql.operations._configurations_operations import ConfigurationsOperations as MySqlConfigurationsOperations
 from azure.mgmt.rdbms.postgresql.operations._configurations_operations import ConfigurationsOperations as PostgreSqlConfigurationsOperations
-from azure.mgmt.rdbms.mysql.operations._databases_operations import DatabasesOperations as MySqlDatabasesOperations
 from azure.mgmt.rdbms.postgresql.operations._databases_operations import DatabasesOperations as PostgreSqlDatabasesOperations
-
-from azure.mgmt.rdbms.mysql.operations._server_keys_operations import ServerKeysOperations as MySqlServerKeysOperations
 from azure.mgmt.rdbms.postgresql.operations._server_keys_operations import ServerKeysOperations as PostgreSqlServerKeysOperations
-
-from azure.mgmt.rdbms.mysql.operations._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations as MySqlPrivateEndpointConnectionsOperations
 from azure.mgmt.rdbms.postgresql.operations._private_endpoint_connections_operations import PrivateEndpointConnectionsOperations as PostgreSqlPrivateEndpointConnectionsOperations
-
-
 from azure.mgmt.rdbms.postgresql.operations._location_based_performance_tier_operations import LocationBasedPerformanceTierOperations as PostgreSQLLocationOperations
 from azure.mgmt.rdbms.mariadb.operations._location_based_performance_tier_operations import LocationBasedPerformanceTierOperations as MariaDBLocationOperations
 from ._client_factory import get_mariadb_management_client, get_mysql_management_client, cf_mysql_db, cf_mariadb_db, \
@@ -528,13 +524,13 @@ def _firewall_rule_update_custom_func(instance, start_ip_address=None, end_ip_ad
 
 
 def _vnet_rule_create(client, resource_group_name, server_name, virtual_network_rule_name, virtual_network_subnet_id, ignore_missing_vnet_service_endpoint):
-    if isinstance(client, MySqlFirewallRulesOperations):
+    if isinstance(client, MySqlVirtualNetworkRulesOperations):
         parameters = mysql.models.VirtualNetworkRule(
             name=virtual_network_rule_name,
             virtual_network_subnet_id=virtual_network_subnet_id,
             ignore_missing_vnet_service_endpoint=ignore_missing_vnet_service_endpoint
         )
-    elif isinstance(client, PostgreSqlFirewallRulesOperations):
+    elif isinstance(client, PostgreSqlVirtualNetworkRulesOperations):
         parameters = postgresql.models.VirtualNetworkRule(
             name=virtual_network_rule_name,
             virtual_network_subnet_id=virtual_network_subnet_id,
@@ -578,7 +574,7 @@ def _configuration_update(client, resource_group_name, server_name, configuratio
             value=value,
             source=source,
         )
-    elif isinstance(client, PostgreSqlFirewallRulesOperations):
+    elif isinstance(client, PostgreSqlConfigurationsOperations):
         parameters = postgresql.models.Configuration(
             name=configuration_name,
             value=value,
@@ -695,9 +691,9 @@ def _update_private_endpoint_connection_status(cmd, client, resource_group_name,
     private_endpoint_connection.private_link_service_connection_state = private_link_service_connection_state
 
     return client.begin_create_or_update(resource_group_name=resource_group_name,
-                                   server_name=server_name,
-                                   private_endpoint_connection_name=private_endpoint_connection_name,
-                                   parameters=private_endpoint_connection)
+                                         server_name=server_name,
+                                         private_endpoint_connection_name=private_endpoint_connection_name,
+                                         parameters=private_endpoint_connection)
 
 
 def approve_private_endpoint_connection(cmd, client, resource_group_name, server_name, private_endpoint_connection_name,
@@ -732,11 +728,7 @@ def server_key_create(client, resource_group_name, server_name, kid):
         parameters = postgresql.models.ServerKey(
             uri=kid
         )
-    else:
-        parameters = mariadb.models.ServerKey(
-            uri=kid
-        )
-
+
     return client.begin_create_or_update(resource_group_name, key_name, server_name, parameters)
 
 
@@ -871,7 +863,7 @@ def check_server_name_availability(check_name_client, parameters):
     server_availability = check_name_client.execute(parameters)
     if not server_availability.name_available:
         raise CLIError("The server name '{}' already exists.Please re-run command with some "
-                       "other server name.".format(server_name))
+                       "other server name.".format(parameters.name))
     return True
 
 

src/azure-cli/azure/cli/command_modules/rdbms/flexible_server_custom_common.py

@@ -60,16 +60,16 @@ def firewall_rule_create_func(client, resource_group_name, server_name, firewall
 
     if isinstance(client, MySqlFirewallRulesOperations):
         parameters = mysql_models.FirewallRule(
-            name = firewall_rule_name,
-            start_ip_address = start_ip_address,
-            end_ip_address = end_ip_address
+            name=firewall_rule_name,
+            start_ip_address=start_ip_address,
+            end_ip_address=end_ip_address
         )
-        
+
     elif isinstance(client, PostgresFirewallRulesOperations):
         parameters = postgres_models.FirewallRule(
-            name = firewall_rule_name,
-            start_ip_address = start_ip_address,
-            end_ip_address = end_ip_address
+            name=firewall_rule_name,
+            start_ip_address=start_ip_address,
+            end_ip_address=end_ip_address
         )
 
     return client.begin_create_or_update(

src/azure-cli/azure/cli/command_modules/rdbms/flexible_server_custom_mysql.py

@@ -5,8 +5,8 @@
 
 # pylint: disable=unused-argument, line-too-long
 
-from msrestazure.azure_exceptions import CloudError
 from azure.core.exceptions import ResourceNotFoundError
+from msrestazure.azure_exceptions import CloudError
 from msrestazure.tools import resource_id, is_valid_resource_id, parse_resource_id  # pylint: disable=import-error
 from knack.log import get_logger
 from azure.cli.core.commands.client_factory import get_subscription_id
@@ -324,8 +324,7 @@ def flexible_server_update_custom_func(cmd, instance,
     if assign_identity:
         if server_module_path.find('mysql'):
             if instance.identity is None:
-                instance.identity = mysql_flexibleservers.models.Identity(
-                    type=mysql_flexibleservers.models.ResourceIdentityType.system_assigned.value)
+                instance.identity = mysql_flexibleservers.models.Identity()
             params.identity = instance.identity
 
     return params
@@ -369,9 +368,9 @@ def flexible_parameter_update(client, server_name, configuration_name, resource_
         source = "user-override"
 
     parameters = mysql_flexibleservers.models.Configuration(
-        name = configuration_name,
-        value = value,
-        source = source
+        name=configuration_name,
+        value=value,
+        source=source
     )
 
     return client.begin_update(resource_group_name, server_name, configuration_name, parameters)
@@ -471,8 +470,7 @@ def _create_server(db_context, cmd, resource_group_name, server_name, location,
         tags=tags)
 
     if assign_identity:
-        parameters.identity = mysql_flexibleservers.models.Identity(
-            type=mysql_flexibleservers.models.ResourceIdentityType.system_assigned.value)
+        parameters.identity = mysql_flexibleservers.models.Identity()
 
     return resolve_poller(
         server_client.begin_create(resource_group_name, server_name, parameters), cmd.cli_ctx,
@@ -555,34 +553,36 @@ def _create_database(db_context, cmd, resource_group_name, server_name, database
     # check for existing database, create if not
     cf_db, logging_name = db_context.cf_db, db_context.logging_name
     database_client = cf_db(cmd.cli_ctx, None)
-    # try:
-    #     database_client.get(resource_group_name, server_name, database_name)
-    # except ResourceNotFoundError:
-    logger.warning('Creating %s database \'%s\'...', logging_name, database_name)
-    parameters = mysql_flexibleservers.models.Database(
-        name = database_name,
-        charset = 'utf8'
-    )
+    try:
+        database_client.get(resource_group_name, server_name, database_name)
+    except ResourceNotFoundError:
+        logger.warning('Creating %s database \'%s\'...', logging_name, database_name)
+        parameters = mysql_flexibleservers.models.Database(
+            name=database_name,
+            charset='utf8'
+        )
     resolve_poller(
         database_client.begin_create_or_update(resource_group_name, server_name, database_name, parameters), cmd.cli_ctx,
         '{} Database Create/Update'.format(logging_name))
 
+
 def database_create_func(client, resource_group_name=None, server_name=None, database_name=None, charset=None, collation=None):
     if charset is None:
         charset = 'utf8'
 
     parameters = mysql_flexibleservers.models.Database(
-            name = database_name,
-            charset = charset,
-            collation = collation
-        )
-    
+        name=database_name,
+        charset=charset,
+        collation=collation
+    )
+
     return client.begin_create_or_update(
         resource_group_name,
         server_name,
         database_name,
         parameters)
 
+
 def _create_mysql_connection_string(host, database_name, user_name, password):
     connection_kwargs = {
         'host': host,

src/azure-cli/azure/cli/command_modules/rdbms/flexible_server_custom_postgres.py

@@ -45,9 +45,6 @@ def flexible_server_create(cmd, client,
     pg_arguments_validator(tier, sku_name, storage_mb, sku_info, version=version)
     storage_mb *= 1024
 
-
-
-    # try:
     db_context = DbContext(
         azure_sdk=postgresql_flexibleservers, cf_firewall=cf_postgres_flexible_firewall_rules,
         logging_name='PostgreSQL', command_group='postgres', server_client=client)
@@ -235,8 +232,7 @@ def flexible_server_update_custom_func(cmd, instance,
     if assign_identity:
         if server_module_path.find('postgres'):
             if instance.identity is None:
-                instance.identity = postgresql_flexibleservers.models.Identity(
-                    type=postgresql_flexibleservers.models.ResourceIdentityType.system_assigned.value)
+                instance.identity = postgresql_flexibleservers.models.Identity()
             params.identity = instance.identity
     return params
 
@@ -285,9 +281,9 @@ def flexible_parameter_update(client, server_name, configuration_name, resource_
         source = "user-override"
 
     parameters = postgresql_flexibleservers.models.Configuration(
-        configuration_name = configuration_name,
-        value = value,
-        source = source
+        configuration_name=configuration_name,
+        value=value,
+        source=source
     )
 
     return client.begin_update(resource_group_name, server_name, configuration_name, parameters)
@@ -327,8 +323,7 @@ def _create_server(db_context, cmd, resource_group_name, server_name, location,
         tags=tags)
 
     if assign_identity:
-        parameters.identity = postgresql_flexibleservers.models.Identity(
-            type=postgresql_flexibleservers.models.ResourceIdentityType.system_assigned.value)
+        parameters.identity = postgresql_flexibleservers.models.Identity()
 
     return resolve_poller(
         server_client.begin_create(resource_group_name, server_name, parameters), cmd.cli_ctx,