def validate_diagnostic_settings(cmd, namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
from msrestazure.tools import is_valid_resource_id, resource_id
from knack.util import CLIError
resource_group_error = "--resource-group is required when name is provided for storage account or workspace or " \
"service bus namespace and rule. "
get_target_resource_validator('resource_uri', required=True, preserve_resource_group_parameter=True)(cmd, namespace)
if namespace.storage_account and not is_valid_resource_id(namespace.storage_account):
if namespace.resource_group_name is None:
raise CLIError(resource_group_error)
namespace.storage_account = resource_id(subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='microsoft.Storage',
type='storageAccounts',
name=namespace.storage_account)
if namespace.workspace and not is_valid_resource_id(namespace.workspace):
if namespace.resource_group_name is None:
raise CLIError(resource_group_error)
namespace.workspace = resource_id(subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='microsoft.OperationalInsights',
type='workspaces',
name=namespace.workspace)
if not namespace.storage_account and not namespace.workspace and not namespace.event_hub:
raise CLIError(
'One of the following parameters is expected: --storage-account, --event-hub-name, or --workspace.')
try:
del namespace.resource_group_name
except AttributeError:
pass
def process_nw_test_connectivity_namespace(cmd, namespace):
from msrestazure.tools import is_valid_resource_id, resource_id, parse_resource_id
compute_client = get_mgmt_service_client(cmd.cli_ctx, ResourceType.MGMT_COMPUTE).virtual_machines
vm_name = parse_resource_id(namespace.source_resource)['name']
rg = namespace.resource_group_name or parse_resource_id(namespace.source_resource).get('resource_group', None)
if not rg:
raise CLIError('usage error: --source-resource ID | --source-resource NAME --resource-group NAME')
vm = compute_client.get(rg, vm_name)
namespace.location = vm.location # pylint: disable=no-member
get_network_watcher_from_location(remove=True)(cmd, namespace)
if namespace.source_resource and not is_valid_resource_id(namespace.source_resource):
namespace.source_resource = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=rg,
namespace='Microsoft.Compute',
type='virtualMachines',
name=namespace.source_resource)
if namespace.dest_resource and not is_valid_resource_id(namespace.dest_resource):
namespace.dest_resource = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Compute',
type='virtualMachines',
name=namespace.dest_resource)
def process_nw_packet_capture_create_namespace(cmd, namespace):
from msrestazure.tools import is_valid_resource_id, resource_id
get_network_watcher_from_vm(cmd, namespace)
storage_usage = CLIError('usage error: --storage-account NAME_OR_ID [--storage-path '
'PATH] [--file-path PATH] | --file-path PATH')
if not namespace.storage_account and not namespace.file_path:
raise storage_usage
if namespace.storage_path and not namespace.storage_account:
raise storage_usage
if not is_valid_resource_id(namespace.vm):
namespace.vm = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Compute',
type='virtualMachines',
name=namespace.vm)
if namespace.storage_account and not is_valid_resource_id(namespace.storage_account):
namespace.storage_account = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Storage',
type='storageAccounts',
name=namespace.storage_account)
if namespace.file_path:
file_path = namespace.file_path
if not file_path.endswith('.cap'):
raise CLIError("usage error: --file-path PATH must end with the '*.cap' extension")
file_path = file_path.replace('/', '\\')
namespace.file_path = file_path
def _validate_name_or_id(
resource_group_name, property_value, property_type, parent_value, parent_type):
from azure.cli.core.commands.client_factory import get_subscription_id
has_parent = parent_type is not None
if is_valid_resource_id(property_value):
resource_id_parts = parse_resource_id(property_value)
value_supplied_was_id = True
elif has_parent:
resource_id_parts = dict(
name=parent_value,
resource_group=resource_group_name,
namespace=parent_type.split('/')[0],
type=parent_type.split('/')[1],
subscription=get_subscription_id(),
child_name=property_value,
child_type=property_type)
value_supplied_was_id = False
else:
resource_id_parts = dict(
name=property_value,
resource_group=resource_group_name,
namespace=property_type.split('/')[0],
type=property_type.split('/')[1],
subscription=get_subscription_id())
value_supplied_was_id = False
return (resource_id_parts, value_supplied_was_id)
def handle_folding(namespace):
base_name_val = getattr(namespace, base_name)
type_field_val = getattr(namespace, type_field)
parent_name_val = getattr(namespace, parent_name) if parent_name else None
if base_name_val is None or type_field_val is not None:
# Either no name was specified, or the user specified the type of resource
# (i.e. new/existing/none)
pass
elif base_name_val in ('', '""', "''"):
# An empty name specified - that means that we are neither referencing an existing
# field, or the name is set to an empty string. We check for all types of quotes
# so scripts can run cross-platform.
if not none_flag_value:
raise CLIError('Field {} cannot be none.'.format(make_camel_case(base_name)))
setattr(namespace, type_field, none_flag_value)
setattr(namespace, base_name, None)
else:
from azure.cli.core.commands.client_factory import get_subscription_id
has_parent = parent_name is not None and parent_type is not None
if is_valid_resource_id(base_name_val):
resource_id_parts = parse_resource_id(base_name_val)
elif has_parent:
if not parent_name_val and base_required:
raise CLIError("Must specify '{}' when specifying '{}' name.".format(
parent_option_flag or parent_name, base_name))
resource_id_parts = dict(
name=parent_name_val,
resource_group=namespace.resource_group_name,
namespace=parent_type.split('/')[0],
type=parent_type.split('/')[1],
subscription=get_subscription_id(),
child_name=base_name_val,
child_type=resource_type)
else:
resource_id_parts = dict(
name=base_name_val,
resource_group=namespace.resource_group_name,
namespace=resource_type.split('/')[0],
type=resource_type.split('/')[1],
subscription=get_subscription_id())
if resource_exists(**resource_id_parts):
setattr(namespace, type_field, existing_id_flag_value)
setattr(namespace, base_name, resource_id(**resource_id_parts))
elif is_valid_resource_id(base_name_val):
raise CLIError('ID {} does not exist. Please specify '
'a name to create a new resource.'.format(
resource_id(**resource_id_parts)))
elif not new_flag_value:
raise CLIError('Referenced resource {} does not exist. Please create the required '
'resource and try again.'.format(resource_id(**resource_id_parts)))
else:
setattr(namespace, type_field, new_flag_value)
def validate_diagnostic_settings(cmd, namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
from msrestazure.tools import is_valid_resource_id, resource_id, parse_resource_id
from knack.util import CLIError
get_target_resource_validator('resource_uri', required=True, preserve_resource_group_parameter=True)(cmd, namespace)
if not namespace.resource_group_name:
namespace.resource_group_name = parse_resource_id(namespace.resource_uri)['resource_group']
if namespace.storage_account and not is_valid_resource_id(namespace.storage_account):
namespace.storage_account = resource_id(subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='microsoft.Storage',
type='storageAccounts',
name=namespace.storage_account)
if namespace.workspace and not is_valid_resource_id(namespace.workspace):
namespace.workspace = resource_id(subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='microsoft.OperationalInsights',
type='workspaces',
name=namespace.workspace)
if namespace.event_hub and is_valid_resource_id(namespace.event_hub):
namespace.event_hub = parse_resource_id(namespace.event_hub)['name']
if namespace.event_hub_rule:
if not is_valid_resource_id(namespace.event_hub_rule):
if not namespace.event_hub:
raise CLIError('usage error: --event-hub-rule ID | --event-hub-rule NAME --event-hub NAME')
# use value from --event-hub if the rule is a name
namespace.event_hub_rule = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.EventHub',
type='namespaces',
name=namespace.event_hub,
child_type_1='AuthorizationRules',
child_name_1=namespace.event_hub_rule)
elif not namespace.event_hub:
# extract the event hub name from `--event-hub-rule` if provided as an ID
namespace.event_hub = parse_resource_id(namespace.event_hub_rule)['name']
if not any([namespace.storage_account, namespace.workspace, namespace.event_hub]):
raise CLIError(
'usage error - expected one or more: --storage-account NAME_OR_ID | --workspace NAME_OR_ID '
'| --event-hub NAME_OR_ID | --event-hub-rule ID')
try:
del namespace.resource_group_name
except AttributeError:
pass
def validate_diagnostic_settings(namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
resource_group_error = "--resource-group is required when name is provided for "\
"storage account or workspace or service bus namespace and rule. "
if namespace.namespace or namespace.rule_name:
if namespace.namespace is None:
raise CLIError(resource_group_error)
if namespace.rule_name is None:
raise CLIError(resource_group_error)
if namespace.resource_group is None:
raise CLIError(resource_group_error)
if not is_valid_resource_id(namespace.namespace):
namespace.service_bus_rule_id = resource_id(subscription=get_subscription_id(),
resource_group=namespace.resource_group,
namespace='microsoft.ServiceBus',
type='namespaces',
name=namespace.namespace,
child_type='AuthorizationRules',
child_name=namespace.rule_name)
else:
resource_dict = parse_resource_id(namespace.namespace)
namespace.service_bus_rule_id = resource_id(subscription=resource_dict['subscription'],
resource_group=resource_dict['resource_group'],
namespace=resource_dict['namespace'],
type=resource_dict['type'],
name=resource_dict['name'],
child_type='AuthorizationRules',
child_name=namespace.rule_name)
if namespace.storage_account and not is_valid_resource_id(namespace.storage_account):
if namespace.resource_group is None:
raise CLIError(resource_group_error)
namespace.storage_account = resource_id(subscription=get_subscription_id(),
resource_group=namespace.resource_group,
namespace='microsoft.Storage',
type='storageAccounts',
name=namespace.storage_account)
if namespace.workspace and not is_valid_resource_id(namespace.workspace):
if namespace.resource_group is None:
raise CLIError(resource_group_error)
namespace.workspace = resource_id(subscription=get_subscription_id(),
resource_group=namespace.resource_group,
namespace='microsoft.OperationalInsights',
type='workspaces', name=namespace.workspace)
_validate_tags(namespace)
def _validate_vm_create_nics(namespace):
nics_value = namespace.nics
nics = []
if not nics_value:
namespace.nic_type = 'new'
return
if not isinstance(nics_value, list):
nics_value = [nics_value]
for n in nics_value:
nics.append({
'id': n if '/' in n else resource_id(name=n,
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='networkInterfaces',
subscription=get_subscription_id()),
'properties': {
'primary': nics_value[0] == n
}
})
namespace.nics = nics
namespace.nic_type = 'existing'
namespace.public_ip_type = None
def create(cmd, client, resource_group_name, activity_log_alert_name, scopes=None, condition=None,
action_groups=frozenset(), tags=None, disable=False, description=None, webhook_properties=None):
from msrestazure.tools import resource_id
from azure.mgmt.monitor.models import (ActivityLogAlertResource, ActivityLogAlertAllOfCondition,
ActivityLogAlertLeafCondition, ActivityLogAlertActionList)
from azure.mgmt.monitor.models import ActivityLogAlertActionGroup as ActionGroup
from azure.cli.core.commands.client_factory import get_subscription_id
from knack.util import CLIError
if not scopes:
scopes = [resource_id(subscription=get_subscription_id(cmd.cli_ctx), resource_group=resource_group_name)]
if _get_alert_settings(client, resource_group_name, activity_log_alert_name, throw_if_missing=False):
raise CLIError('The activity log alert {} already exists in resource group {}.'.format(activity_log_alert_name,
resource_group_name))
# Add alert conditions
condition = condition or ActivityLogAlertAllOfCondition(
all_of=[ActivityLogAlertLeafCondition(field='category', equals='ServiceHealth')])
# Add action groups
action_group_rids = _normalize_names(cmd.cli_ctx, action_groups, resource_group_name, 'microsoft.insights',
'actionGroups')
action_groups = [ActionGroup(action_group_id=i, webhook_properties=webhook_properties) for i in action_group_rids]
alert_actions = ActivityLogAlertActionList(action_groups=action_groups)
settings = ActivityLogAlertResource(location='global', scopes=scopes, condition=condition,
actions=alert_actions, enabled=not disable, description=description, tags=tags)
return client.create_or_update(resource_group_name=resource_group_name,
activity_log_alert_name=activity_log_alert_name, activity_log_alert=settings)
def _handle_vm_nics(namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
nics_value = namespace.network_interface_ids
nics = []
if not nics_value:
namespace.network_interface_type = 'new'
return
namespace.network_interface_type = 'existing'
if not isinstance(nics_value, list):
nics_value = [nics_value]
for n in nics_value:
nics.append({
'id': n if '/' in n else resource_id(name=n,
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='networkInterfaces',
subscription=get_subscription_id()),
'properties': {
'primary': nics_value[0] == n
}
})
namespace.network_interface_ids = nics
namespace.network_interface_type = 'existing'
namespace.public_ip_address_type = 'none'
def validate_nsg_name(namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
vm_id = resource_id(name=namespace.vm_name, resource_group=namespace.resource_group_name,
namespace='Microsoft.Compute', type='virtualMachines',
subscription=get_subscription_id())
namespace.network_security_group_name = namespace.network_security_group_name \
or '{}_NSG_{}'.format(namespace.vm_name, hash_string(vm_id, length=8))
def _validate_vm_create_nics(namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
nics_value = namespace.nics
nics = []
if not nics_value:
namespace.nic_type = 'new'
logger.debug('new NIC will be created')
return
if not isinstance(nics_value, list):
nics_value = [nics_value]
for n in nics_value:
nics.append({
'id': n if '/' in n else resource_id(name=n,
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='networkInterfaces',
subscription=get_subscription_id()),
'properties': {
'primary': nics_value[0] == n
}
})
namespace.nics = nics
namespace.nic_type = 'existing'
namespace.public_ip_type = None
logger.debug('existing NIC(s) will be used')
def validate_subnet_name_or_id(namespace):
""" Validates a subnet ID or, if a name is provided, formats it as an ID. """
if namespace.virtual_network_name is None and namespace.subnet is None:
return
if namespace.subnet == '':
return
# error if vnet-name is provided without subnet
if namespace.virtual_network_name and not namespace.subnet:
raise CLIError('You must specify --subnet name when using --vnet-name.')
# determine if subnet is name or ID
is_id = is_valid_resource_id(namespace.subnet)
# error if vnet-name is provided along with a subnet ID
if is_id and namespace.virtual_network_name:
raise argparse.ArgumentError(None, 'Please omit --vnet-name when specifying a subnet ID')
elif not is_id and not namespace.virtual_network_name:
raise argparse.ArgumentError(None,
'Please specify --vnet-name when specifying a subnet name')
if not is_id:
namespace.subnet = resource_id(
subscription=get_subscription_id(),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='virtualNetworks',
name=namespace.virtual_network_name,
child_type='subnets',
child_name=namespace.subnet)
def simple_validator(cmd, namespace):
if namespace.virtual_network_name is None and namespace.subnet is None:
return
if namespace.subnet == '':
return
usage_error = ValueError('incorrect usage: ( --subnet ID | --subnet NAME --vnet-name NAME)')
# error if vnet-name is provided without subnet
if namespace.virtual_network_name and not namespace.subnet:
raise usage_error
# determine if subnet is name or ID
is_id = is_valid_resource_id(namespace.subnet)
# error if vnet-name is provided along with a subnet ID
if is_id and namespace.virtual_network_name:
raise usage_error
elif not is_id and not namespace.virtual_network_name:
raise usage_error
if not is_id:
namespace.subnet = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='virtualNetworks',
name=namespace.virtual_network_name,
child_type_1='subnets',
child_name_1=namespace.subnet)
def _replica_create(cmd, client, resource_group_name, server_name, source_server, no_wait=False, **kwargs):
provider = 'Microsoft.DBForMySQL' if isinstance(client, MySqlServersOperations) else 'Microsoft.DBforPostgreSQL'
# set source server id
if not is_valid_resource_id(source_server):
if len(source_server.split('/')) == 1:
source_server = resource_id(subscription=get_subscription_id(cmd.cli_ctx),
resource_group=resource_group_name,
namespace=provider,
type='servers',
name=source_server)
else:
raise CLIError('The provided source-server {} is invalid.'.format(source_server))
source_server_id_parts = parse_resource_id(source_server)
try:
source_server_object = client.get(source_server_id_parts['resource_group'], source_server_id_parts['name'])
except CloudError as e:
raise CLIError('Unable to get source server: {}.'.format(str(e)))
parameters = None
if provider == 'Microsoft.DBForMySQL':
from azure.mgmt.rdbms import mysql
parameters = mysql.models.ServerForCreate(
sku=mysql.models.Sku(name=source_server_object.sku.name),
properties=mysql.models.ServerPropertiesForReplica(source_server_id=source_server),
location=source_server_object.location)
return sdk_no_wait(no_wait, client.create, resource_group_name, server_name, parameters)
def _db_create_special(
client,
source_db,
dest_db,
kwargs):
# Determine server location
kwargs['location'] = get_server_location(
server_name=dest_db.server_name,
resource_group_name=dest_db.resource_group_name)
# Set create mode properties
subscription_id = get_subscription_id()
kwargs['source_database_id'] = (
'/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}'
.format(quote(subscription_id),
quote(source_db.resource_group_name),
quote(source_db.server_name),
quote(source_db.database_name)))
# Create
return client.create_or_update(
server_name=dest_db.server_name,
resource_group_name=dest_db.resource_group_name,
database_name=dest_db.database_name,
parameters=kwargs)
def _validator(namespace):
name_or_id = getattr(namespace, dest)
rg = namespace.resource_group_name
res_ns = namespace.namespace
parent = namespace.parent
res_type = namespace.resource_type
usage_error = CLIError('usage error: --{0} ID | --{0} NAME --resource-group NAME '
'--{0}-namespace NAMESPACE [--{0}-parent PARENT] '
'[--{0}-type TYPE]'.format(dest))
if not name_or_id and required:
raise usage_error
elif name_or_id:
if is_valid_resource_id(name_or_id) and any((res_ns, parent, res_type)):
raise usage_error
elif not is_valid_resource_id(name_or_id):
from azure.cli.core.commands.client_factory import get_subscription_id
if res_type and '/' in res_type:
res_ns = res_ns or res_type.rsplit('/', 1)[0]
res_type = res_type.rsplit('/', 1)[1]
if not all((rg, res_ns, res_type, name_or_id)):
raise usage_error
setattr(namespace, dest,
'/subscriptions/{}/resourceGroups/{}/providers/{}/{}{}/{}'.format(
get_subscription_id(), rg, res_ns, parent + '/' if parent else '',
res_type, name_or_id))
del namespace.namespace
del namespace.parent
del namespace.resource_type
def _execute_remediation_operation(
cmd,
client,
operation_name,
management_group_name=None,
resource_group_name=None,
resource=None,
namespace=None,
resource_type_parent=None,
resource_type=None,
remediation_name=None):
subscription_id = get_subscription_id(cmd.cli_ctx)
scope = _build_remediation_scope(
management_group_name,
subscription_id,
resource_group_name,
resource,
resource_type_parent,
resource_type,
namespace)
operation = getattr(client, operation_name)
if remediation_name is None:
return operation(resource_id=_remove_leading_and_trailing_slash(scope))
return operation(resource_id=_remove_leading_and_trailing_slash(scope), remediation_name=remediation_name)
def _get_resource_id(val, resource_group, resource_type, resource_namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
if is_valid_resource_id(val):
return val
return resource_id(name=val, resource_group=resource_group, namespace=resource_namespace, type=resource_type,
subscription=get_subscription_id())
def get_vnet_validator(dest):
SubResource = get_sdk(ResourceType.MGMT_NETWORK, 'SubResource', mod='models')
subscription_id = get_subscription_id()
def _validate_vnet_name_or_id(namespace):
resource_group = namespace.resource_group_name
names_or_ids = getattr(namespace, dest)
ids = []
if names_or_ids == [""] or not names_or_ids:
return
for val in names_or_ids:
if not is_valid_resource_id(val):
val = resource_id(
subscription=subscription_id,
resource_group=resource_group,
namespace='Microsoft.Network', type='virtualNetworks',
name=val
)
ids.append(SubResource(id=val))
setattr(namespace, dest, ids)
return _validate_vnet_name_or_id
def _get_scope(
resource_group_name,
provider_namespace,
resource_type,
resource_name):
subscription_id = get_subscription_id()
if provider_namespace == RESOURCES_NAMESPACE:
if resource_group_name:
scope = (
'/subscriptions/{}/resourceGroups/{}'
.format(quote(subscription_id),
quote(resource_group_name)))
else:
scope = (
'/subscriptions/{}'
.format(quote(subscription_id)))
else:
scope = (
'/subscriptions/{}/resourceGroups/{}/providers/{}/{}/{}'
.format(quote(subscription_id),
quote(resource_group_name),
quote(provider_namespace),
quote(resource_type),
quote(resource_name)))
return scope
def _get_arm_resource_info(resource_group_name):
if resource_group_name:
resource_type = RESOURCE_TYPE_RESOURCE_GROUPS
resource_name = resource_group_name
else:
resource_type = RESOURCE_TYPE_SUBSCRIPTIONS
resource_name = get_subscription_id()
return resource_type, resource_name
def _generate_ag_subproperty_id(namespace, child_type, child_name, subscription=None):
return resource_id(
subscription=subscription or get_subscription_id(),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='applicationGateways',
name=namespace.application_gateway_name,
child_type=child_type,
child_name=child_name)
def _validate_artifacts(namespace):
if namespace.artifacts:
from azure.cli.core.commands.client_factory import get_subscription_id
lab_resource_id = resource_id(subscription=get_subscription_id(),
resource_group=namespace.resource_group,
namespace='Microsoft.DevTestLab',
type='labs',
name=namespace.lab_name)
namespace.artifacts = _update_artifacts(namespace.artifacts, lab_resource_id)
def _validate_name_or_id(public_ip):
# determine if public_ip_address is name or ID
is_id = is_valid_resource_id(public_ip)
return public_ip if is_id else resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='publicIPAddresses',
name=public_ip)
def _generate_lb_subproperty_id(namespace, child_type, child_name, subscription=None):
return resource_id(
subscription=subscription or get_subscription_id(),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='loadBalancers',
name=namespace.load_balancer_name,
child_type=child_type,
child_name=child_name)
def validate_route_filter(namespace):
if namespace.route_filter:
if not is_valid_resource_id(namespace.route_filter):
namespace.route_filter = resource_id(
subscription=get_subscription_id(),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='routeFilters',
name=namespace.route_filter)
def validate_route_filter(cmd, namespace):
from msrestazure.tools import is_valid_resource_id, resource_id
if namespace.route_filter:
if not is_valid_resource_id(namespace.route_filter):
namespace.route_filter = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='routeFilters',
name=namespace.route_filter)
def _validate_name_or_id(value, resource_type):
if not is_valid_resource_id(value):
subscription = getattr(namespace, 'subscription', get_subscription_id(cmd.cli_ctx))
return resource_id(
subscription=subscription,
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type=resource_type,
name=value)
return value
def _generate_ag_subproperty_id(cli_ctx, namespace, child_type, child_name, subscription=None):
from msrestazure.tools import resource_id
return resource_id(
subscription=subscription or get_subscription_id(cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='applicationGateways',
name=namespace.application_gateway_name,
child_type_1=child_type,
child_name_1=child_name)
def _validate_vnet_name_or_id(cmd, namespace):
SubResource = cmd.get_models('SubResource')
subscription_id = get_subscription_id(cmd.cli_ctx)
resource_group = namespace.resource_group_name
names_or_ids = getattr(namespace, dest)
ids = []
if names_or_ids == [""] or not names_or_ids:
return
for val in names_or_ids:
if not is_valid_resource_id(val):
val = resource_id(subscription=subscription_id,
resource_group=resource_group,
namespace='Microsoft.Network',
type='virtualNetworks',
name=val)
ids.append(SubResource(id=val))
setattr(namespace, dest, ids)
def create_or_update(cls, cmd, resource_group_name, container_app_name, auth_config_name, auth_config_envelope, no_wait=False):
management_hostname = cmd.cli_ctx.cloud.endpoints.resource_manager
api_version = STABLE_API_VERSION
sub_id = get_subscription_id(cmd.cli_ctx)
request_url = f"{management_hostname}subscriptions/{sub_id}/resourceGroups/{resource_group_name}/providers/Microsoft.App/containerApps/{container_app_name}/authConfigs/{auth_config_name}?api-version={api_version}"
if "properties" not in auth_config_envelope: # sdk does this for us
temp_env = auth_config_envelope
auth_config_envelope = {}
auth_config_envelope["properties"] = temp_env
r = send_raw_request(cmd.cli_ctx, "PUT", request_url, body=json.dumps(auth_config_envelope))
if no_wait:
return r.json()
elif r.status_code == 201:
request_url = f"{management_hostname}subscriptions/{sub_id}/resourceGroups/{resource_group_name}/providers/Microsoft.App/containerApps/{container_app_name}/authConfigs/{auth_config_name}?api-version={api_version}"
return poll(cmd, request_url, "waiting")
return r.json()
def delete(cls, cmd, resource_group_name, container_app_name, auth_config_name, no_wait=False):
management_hostname = cmd.cli_ctx.cloud.endpoints.resource_manager
api_version = STABLE_API_VERSION
sub_id = get_subscription_id(cmd.cli_ctx)
request_url = f"{management_hostname}subscriptions/{sub_id}/resourceGroups/{resource_group_name}/providers/Microsoft.App/containerApps/{container_app_name}/authConfigs/{auth_config_name}?api-version={api_version}"
r = send_raw_request(cmd.cli_ctx, "DELETE", request_url)
if no_wait:
return # API doesn't return JSON (it returns no content)
elif r.status_code in [200, 201, 202, 204]:
request_url = f"{management_hostname}subscriptions/{sub_id}/resourceGroups/{resource_group_name}/providers/Microsoft.App/containerApps/{container_app_name}/authConfigs/{auth_config_name}?api-version={api_version}"
if r.status_code == 200: # 200 successful delete, 204 means storage not found
from azure.cli.core.azclierror import ResourceNotFoundError
try:
poll(cmd, request_url, "scheduledfordelete")
except ResourceNotFoundError:
pass
logger.warning('Containerapp AuthConfig successfully deleted')
return
def list_certificates(cls, cmd, resource_group_name, name, formatter=lambda x: x):
certs_list = []
management_hostname = cmd.cli_ctx.cloud.endpoints.resource_manager
api_version = STABLE_API_VERSION
sub_id = get_subscription_id(cmd.cli_ctx)
url_fmt = "{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.App/managedEnvironments/{}/certificates?api-version={}"
request_url = url_fmt.format(
management_hostname.strip('/'),
sub_id,
resource_group_name,
name,
api_version)
r = send_raw_request(cmd.cli_ctx, "GET", request_url, body=None)
j = r.json()
for cert in j["value"]:
formatted = formatter(cert)
certs_list.append(formatted)
return certs_list
def __init__(self, cmd, resource_group_name=None, workspace_name=None, location=None):
from azure.cli.core.commands.client_factory import get_subscription_id
# Hierarchically selects the value for the given key.
# First tries the value provided as argument, as that represents the value from the command line
# then it checks if the key exists in the 'quantum' section in config, and uses that if available.
# finally, it checks in the 'global' section in the config.
def select_value(key, value):
if value is not None:
return value
value = cmd.cli_ctx.config.get('quantum', key, None)
if value is not None:
return value
value = cmd.cli_ctx.config.get(cmd.cli_ctx.config.defaults_section_name, key, None)
return value
self.subscription = get_subscription_id(cmd.cli_ctx)
self.resource_group = select_value('group', resource_group_name)
self.name = select_value('workspace', workspace_name)
self.location = select_value('location', location)
def validate_ip_groups(cmd, namespace):
from msrestazure.tools import is_valid_resource_id, resource_id
def _validate_name_or_id(ip_group, subscription):
# determine if public_ip_address is name or ID
is_id = is_valid_resource_id(ip_group)
return ip_group if is_id else resource_id(
subscription=subscription,
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='ipGroups',
name=ip_group)
subscription = get_subscription_id(cmd.cli_ctx)
if hasattr(namespace, 'destination_ip_groups') and namespace.destination_ip_groups is not None:
for i, ip_group in enumerate(namespace.destination_ip_groups):
namespace.destination_ip_groups[i] = _validate_name_or_id(ip_group, subscription)
if hasattr(namespace, 'source_ip_groups') and namespace.source_ip_groups is not None:
for i, ip_group in enumerate(namespace.source_ip_groups):
namespace.source_ip_groups[i] = _validate_name_or_id(ip_group, subscription)
def process_nw_flow_log_show_namespace(namespace):
from azure.cli.core.commands.arm import parse_resource_id
if not is_valid_resource_id(namespace.nsg):
namespace.nsg = resource_id(
subscription=get_subscription_id(),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='networkSecurityGroups',
name=namespace.nsg)
network_client = get_mgmt_service_client(
ResourceType.MGMT_NETWORK).network_security_groups
id_parts = parse_resource_id(namespace.nsg)
nsg_name = id_parts['name']
rg = id_parts['resource_group']
nsg = network_client.get(rg, nsg_name)
namespace.location = nsg.location # pylint: disable=no-member
get_network_watcher_from_location(remove=True)(namespace)
def _validate_vm_create_availability_set(namespace):
from azure.cli.core.commands.client_factory import get_subscription_id
if namespace.availability_set:
as_id = parse_resource_id(namespace.availability_set)
name = as_id['name']
rg = as_id.get('resource_group', namespace.resource_group_name)
if not check_existence(name, rg, 'Microsoft.Compute',
'availabilitySets'):
raise CLIError(
"Availability set '{}' does not exist.".format(name))
namespace.availability_set = resource_id(
subscription=get_subscription_id(),
resource_group=rg,
namespace='Microsoft.Compute',
type='availabilitySets',
name=name)
logger.debug("adding to specified availability set '%s'",
namespace.availability_set)
def migration_create_func(cmd,
client,
resource_group_name,
server_name,
properties,
migration_id=None):
subscription_id = get_subscription_id(cmd.cli_ctx)
if migration_id is None:
# Convert a UUID to a string of hex digits in standard form
migration_id = str(uuid.uuid4())
r = send_raw_request(
cmd.cli_ctx, "put",
"https://management.azure.com/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{}/migrations/{}?api-version=2020-02-14-privatepreview"
.format(subscription_id, resource_group_name, server_name,
migration_id), None, None, properties)
return r.json()
def _db_create_special(client, source_db, dest_db, kwargs):
# Determine server location
kwargs['location'] = get_server_location(
server_name=dest_db.server_name,
resource_group_name=dest_db.resource_group_name)
# Set create mode properties
subscription_id = get_subscription_id()
kwargs['source_database_id'] = (
'/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}'
.format(quote(subscription_id), quote(source_db.resource_group_name),
quote(source_db.server_name), quote(source_db.database_name)))
# Create
return client.create_or_update(
server_name=dest_db.server_name,
resource_group_name=dest_db.resource_group_name,
database_name=dest_db.database_name,
parameters=kwargs)
def get_resource_id(
cmd,
resource_group_name: str,
provider_name_space: str,
resource_type: str,
resource: str,
):
"""
Gets the resource id for the resource if name is given.
"""
if resource is None or is_valid_resource_id(resource):
return resource
return resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=resource_group_name,
namespace=provider_name_space,
type=resource_type,
name=resource,
)
def validate_subnet(cmd, namespace):
subnet = namespace.virtual_network_subnet_id
subnet_is_id = is_valid_resource_id(subnet)
vnet = namespace.vnet_name
if (subnet_is_id and not vnet) or (not subnet and not vnet):
pass
elif subnet and not subnet_is_id and vnet:
namespace.virtual_network_subnet_id = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='virtualNetworks',
name=vnet,
child_type_1='subnets',
child_name_1=subnet)
else:
raise CLIError('incorrect usage: [--subnet ID | --subnet NAME --vnet-name NAME]')
delattr(namespace, 'vnet_name')
def validate_action_groups(cmd, namespace):
action_groups = getattr(namespace, dest, None)
if not action_groups:
return
from msrestazure.tools import is_valid_resource_id, resource_id
from azure.cli.core.commands.client_factory import get_subscription_id
subscription = get_subscription_id(cmd.cli_ctx)
resource_group = namespace.resource_group_name
for group in action_groups:
if not is_valid_resource_id(group.action_group_id):
group.action_group_id = resource_id(
subscription=subscription,
resource_group=resource_group,
namespace='microsoft.insights',
type='actionGroups',
name=group.action_group_id
)
def ml_endpoint_get_deployment_logs(cmd,
resource_group_name,
workspace_name,
name,
deployment,
tail,
type=ONLINE_ENDPOINT_TYPE,
container=None):
subscription_id = get_subscription_id(cmd.cli_ctx)
ml_client = MLClient(
subscription_id=subscription_id,
resource_group_name=resource_group_name,
default_workspace_name=workspace_name,
credential=AzureCliCredential(),
)
return ml_client.endpoints.get_deployment_logs(type=type,
endpoint_name=name,
deployment_name=deployment,
tail=tail,
container_type=container)
def test_webapp_storagetable_e2e(self):
self.kwargs.update({
'name': 'testconn1',
'subscription': get_subscription_id(self.cli_ctx),
'source_resource_group': 'servicelinker-test-linux-group',
'target_resource_group': 'servicelinker-test-linux-group',
'site': 'servicelinker-storagetable-app',
'account': 'servicelinkerteststorage'
})
# prepare params
name = 'testconn'
target_id = TARGET_RESOURCES.get(RESOURCE.StorageTable).format(**self.kwargs)
# create connection
self.cmd('webapp connection create storage-table --connection {name} -g {source_resource_group} -n {site} '
'--tg {target_resource_group} --account {account} --secret --client-type python')
# list connection
connections = self.cmd(
'webapp connection list -g {source_resource_group} -n {site}',
checks = [
self.check('length(@)', 1),
self.check('[0].authInfo.authType', 'secret'),
self.check('[0].clientType', 'python')
]
).get_output_in_json()
connection_id = connections[0].get('id')
# list configuration
self.cmd('webapp connection list-configuration --connection {name} -g {source_resource_group} -n {site}')
# validate connection
self.cmd('webapp connection validate --connection {name} -g {source_resource_group} -n {site}')
# show connection
self.cmd('webapp connection show --connection {name} -g {source_resource_group} -n {site}')
# delete connection
self.cmd('webapp connection delete --id {} --yes'.format(connection_id))
def test_webapp_appconfig_e2e(self):
self.kwargs.update({
'name': 'testconn1',
'subscription': get_subscription_id(self.cli_ctx),
'source_resource_group': 'servicelinker-test-linux-group',
'target_resource_group': 'servicelinker-test-linux-group',
'site': 'servicelinker-config-app',
'config_store': 'servicelinker-app-configuration'
})
# prepare params
name = 'testconn'
target_id = TARGET_RESOURCES.get(RESOURCE.AppConfig).format(**self.kwargs)
# create connection
self.cmd('webapp connection create appconfig --connection {name} -g {source_resource_group} -n {site} '
'--tg {target_resource_group} --app-config {config_store} --system-identity --client-type python')
# list connection
connections = self.cmd(
'webapp connection list -g {source_resource_group} -n {site}',
checks = [
self.check('length(@)', 1),
self.check('[0].authInfo.authType', 'systemAssignedIdentity'),
self.check('[0].clientType', 'python')
]
).get_output_in_json()
connection_id = connections[0].get('id')
# list configuration
self.cmd('webapp connection list-configuration --connection {name} -g {source_resource_group} -n {site}')
# validate connection
self.cmd('webapp connection validate --connection {name} -g {source_resource_group} -n {site}')
# show connection
self.cmd('webapp connection show --connection {name} -g {source_resource_group} -n {site}')
# delete connection
self.cmd('webapp connection delete --id {} --yes'.format(connection_id))
def test_webapp_confluentkafka_e2e(self):
self.kwargs.update({
'subscription': get_subscription_id(self.cli_ctx),
'source_resource_group': 'servicelinker-test-linux-group',
'target_resource_group': 'servicelinker-test-linux-group',
'site': 'servicelinker-kafka-app2',
})
# prepare params
name = 'testconn'
source_id = SOURCE_RESOURCES.get(RESOURCE.WebApp).format(**self.kwargs)
# create connection
self.cmd(
'webapp connection create confluent-cloud --connection {} --source-id {} '
'--bootstrap-server xxx.eastus.azure.confluent.cloud:9092 --kafka-key Name --kafka-secret Secret '
'--schema-registry https://xxx.eastus.azure.confluent.cloud --schema-key Name --schema-secret Secret '
'--client-type python'.format(name, source_id))
# list connection
connections = self.cmd(
'webapp connection list --source-id {}'.format(source_id),
checks=[
self.check('length(@)', 2),
self.check('[0].clientType', 'python')
]).get_output_in_json()
connection_id = connections[0].get('id')
# list configuration
self.cmd('webapp connection list-configuration --id {}'.format(
connection_id))
# validate connection
self.cmd('webapp connection validate --id {}'.format(connection_id))
# show connection
self.cmd('webapp connection show --id {}'.format(connection_id))
# delete connection
self.cmd(
'webapp connection delete --id {} --yes'.format(connection_id))
def restore_webapp_snapshot(cmd,
resource_group,
name,
time,
slot=None,
restore_config=False,
source_resource_group=None,
source_name=None,
source_slot=None):
client = web_client_factory(cmd.cli_ctx)
if all([source_resource_group, source_name]):
sub_id = get_subscription_id(cmd.cli_ctx)
target_id = "/subscriptions/" + sub_id + "/resourceGroups/" + resource_group + "/providers/Microsoft.Web/sites/" + name
if slot:
target_id = target_id + "/slots/" + slot
target = SnapshotRecoveryTarget(id=target_id)
request = SnapshotRecoveryRequest(False,
snapshot_time=time,
recovery_target=target,
recover_configuration=restore_config)
if source_slot:
return client.web_apps.recover_slot(source_resource_group,
source_name, request,
source_slot)
else:
return client.web_apps.recover(source_resource_group, source_name,
request)
elif any([source_resource_group, source_name]):
raise CLIError(
'usage error: --source-resource-group and --source-name must both be specified if one is used'
)
else:
request = SnapshotRecoveryRequest(True,
snapshot_time=time,
recover_configuration=restore_config)
if slot:
return client.web_apps.recover_slot(resource_group, name, request,
slot)
else:
return client.web_apps.recover(resource_group, name, request)
def _replica_create(cmd,
client,
resource_group_name,
server_name,
source_server,
no_wait=False,
**kwargs):
provider = 'Microsoft.DBForMySQL' if isinstance(
client, MySqlServersOperations) else 'Microsoft.DBforPostgreSQL'
# set source server id
if not is_valid_resource_id(source_server):
if len(source_server.split('/')) == 1:
source_server = resource_id(subscription=get_subscription_id(
cmd.cli_ctx),
resource_group=resource_group_name,
namespace=provider,
type='servers',
name=source_server)
else:
raise CLIError('The provided source-server {} is invalid.'.format(
source_server))
source_server_id_parts = parse_resource_id(source_server)
try:
source_server_object = client.get(
source_server_id_parts['resource_group'],
source_server_id_parts['name'])
except CloudError as e:
raise CLIError('Unable to get source server: {}.'.format(str(e)))
parameters = None
if provider == 'Microsoft.DBForMySQL':
from azure.mgmt.rdbms import mysql
parameters = mysql.models.ServerForCreate(
sku=mysql.models.Sku(name=source_server_object.sku.name),
properties=mysql.models.ServerPropertiesForReplica(
source_server_id=source_server),
location=source_server_object.location)
return sdk_no_wait(no_wait, client.create, resource_group_name,
server_name, parameters)
def validate_workspace_values(cmd, namespace):
"""Parse managed resource_group which can be either resource group name or id"""
from msrestazure.tools import is_valid_resource_id, resource_id
from azure.cli.core.commands.client_factory import get_subscription_id
random_id = id_generator()
subscription_id = get_subscription_id(cmd.cli_ctx)
if not namespace.managed_resource_group:
namespace.managed_resource_group = resource_id(
subscription=subscription_id,
resource_group='databricks-rg-' + namespace.workspace_name + '-' +
random_id)
elif not is_valid_resource_id(namespace.managed_resource_group):
namespace.managed_resource_group = resource_id(
subscription=subscription_id,
resource_group=namespace.managed_resource_group)
# set default values similar to portal
if not namespace.relay_namespace_name:
namespace.relay_namespace_name = 'dbrelay{}'.format(random_id)
if not namespace.storage_account_name:
namespace.storage_account_name = 'dbstorage{}'.format(random_id)
# name to resource id for virtual-network
if namespace.custom_virtual_network_id is not None \
and not is_valid_resource_id(namespace.custom_virtual_network_id):
namespace.custom_virtual_network_id = resource_id(
subscription=subscription_id,
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='virtualNetworks',
name=namespace.custom_virtual_network_id)
# name to resource id for load-balancer
if namespace.load_balancer_id is not None and not is_valid_resource_id(namespace.load_balancer_id):
namespace.load_balancer_id = resource_id(
subscription=subscription_id,
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='loadBalancers',
name=namespace.load_balancer_id)
def test_springcloud_mysql_e2e_kvsecret(self):
self.kwargs.update({
'subscription': get_subscription_id(self.cli_ctx),
'source_resource_group': 'servicelinker-test-linux-group',
'target_resource_group': 'servicelinker-test-linux-group',
'spring': 'servicelinker-springcloud',
'app': 'mysql',
'deployment': 'default',
'server': 'servicelinker-mysql',
'database': 'mysqlDB'
})
# prepare password
user = '******'
keyvaultUri = "https://cupertino-kv-test.vault.azure.net/secrets/TestDbPassword"
# prepare params
name = 'testconn'
source_id = SOURCE_RESOURCES.get(
RESOURCE.SpringCloud).format(**self.kwargs)
target_id = TARGET_RESOURCES.get(RESOURCE.Mysql).format(**self.kwargs)
# create connection
self.cmd(
'spring-cloud connection create mysql --connection {} --source-id {} --target-id {} '
'--secret name={} secret-uri={} --client-type java'.format(
name, source_id, target_id, user, keyvaultUri))
# list connection
connections = self.cmd(
'spring-cloud connection list --source-id {}'.format(source_id),
checks=[
self.check('length(@)', 1),
self.check('[0].authInfo.authType', 'secret'),
self.check('[0].clientType', 'java')
]).get_output_in_json()
connection_id = connections[0].get('id')
# delete connection
self.cmd('spring-cloud connection delete --id {} --yes'.format(
connection_id))
def get_storage_account_id_from_blob_path(cmd,
blob_path,
resource_group,
subscription_id=None):
from msrestazure.tools import resource_id
from azure.cli.core.commands.client_factory import get_subscription_id
logger.debug('Getting storage account id for blob: %s', blob_path)
storage_account_name = blob_path.split('.')[0].split('/')[-1]
if not subscription_id:
subscription_id = get_subscription_id(cmd.cli_ctx)
storage_account_id = resource_id(subscription=subscription_id,
resource_group=resource_group,
namespace='Microsoft.Storage',
type='storageAccounts',
name=storage_account_name)
return storage_account_id
def cli_redis_create_server_link(cmd, client, resource_group_name, name,
server_to_link, replication_role):
redis_client = cf_redis(cmd.cli_ctx)
from azure.cli.core.commands.client_factory import get_subscription_id
from msrestazure.tools import is_valid_resource_id, resource_id
if not is_valid_resource_id(server_to_link):
server_to_link = resource_id(subscription=get_subscription_id(
cmd.cli_ctx),
resource_group=resource_group_name,
namespace='Microsoft.Cache',
type='Redis',
name=server_to_link)
cache_to_link = get_cache_from_resource_id(redis_client, server_to_link)
from azure.mgmt.redis.models import RedisLinkedServerCreateParameters
params = RedisLinkedServerCreateParameters(
linked_redis_cache_id=cache_to_link.id,
linked_redis_cache_location=cache_to_link.location,
server_role=replication_role)
return client.create(resource_group_name, name, cache_to_link.name, params)
def _get_scope_for_event_subscription(
cli_ctx,
resource_id,
topic_name,
resource_group_name):
if resource_id:
# Resource ID is provided, use that as the scope for the event subscription.
scope = resource_id
elif topic_name:
# Topic name is provided, use the topic and resource group to build a scope for the user topic
if resource_group_name is None:
raise CLIError("When --topic-name is specified, the --resource-group-name must also be specified.")
scope = _get_scope(cli_ctx, resource_group_name, EVENTGRID_NAMESPACE, EVENTGRID_TOPICS, topic_name)
elif resource_group_name:
# Event subscription to a resource group.
scope = _get_scope(cli_ctx, resource_group_name, RESOURCES_NAMESPACE, RESOURCE_GROUPS, resource_group_name)
else:
scope = _get_scope(cli_ctx, None, RESOURCES_NAMESPACE, SUBSCRIPTIONS, get_subscription_id(cli_ctx))
return scope
def deleteDeployment(cmd, deploymentId, subscription=None):
"""Deletes a deployment.
deploymentId: The unique id created at the time the deployment was made.
subscription[optional]: Provides an alternate subscripton to use if desired.
"""
if subscription is None:
subscription = get_subscription_id(cmd.cli_ctx)
logger.info("Using default subscription: " + subscription)
profile = Profile(cli_ctx=cmd.cli_ctx)
auth_token = profile.get_raw_token(subscription=subscription)
creds = authentication.BasicTokenAuthentication(
{'access_token': auth_token[0][1]})
ciqsapi = ciqs_api.CiqsApi(creds=creds, base_url=api.getEndpoint())
try:
logger.info("Sending request.")
deleteResponse = ciqsapi.delete_api_deployments_by_subscription_id_by_deployment_id(
subscription, deploymentId)
except msrest.exceptions.HttpOperationError as e:
message = e.response.json()
raise CLIError(message)
return deleteResponse
def validate_subnet(cmd, namespace):
from msrestazure.tools import resource_id, is_valid_resource_id
from azure.cli.core.commands.client_factory import get_subscription_id
subnet = namespace.subnet
subnet_is_id = is_valid_resource_id(subnet)
vnet = namespace.vnet_name
if (subnet_is_id and not vnet) or (not subnet and not vnet):
return
if subnet and not subnet_is_id and vnet:
namespace.subnet = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='virtualNetworks',
name=vnet,
child_type_1='subnets',
child_name_1=subnet)
else:
raise CLIError('incorrect usage: [--subnet ID | --subnet NAME --vnet-name NAME]')
def _get_default_containerapps_location(cmd, location=None):
if location:
return location
default_location = "eastus"
providers_client = None
try:
providers_client = providers_client_factory(cmd.cli_ctx, get_subscription_id(cmd.cli_ctx))
resource_types = getattr(providers_client.get("Microsoft.App"), 'resource_types', [])
res_locations = []
for res in resource_types:
if res and getattr(res, 'resource_type', "") == "workspaces":
res_locations = getattr(res, 'locations', [])
if len(res_locations) > 0:
location = res_locations[0].lower().replace(" ", "").replace("(", "").replace(")", "")
if location:
return location
except Exception: # pylint: disable=broad-except
return default_location
return default_location
def migration_delete_func(cmd,
client,
resource_group_name,
server_name,
migration_name,
yes=None):
subscription_id = get_subscription_id(cmd.cli_ctx)
if not yes:
user_confirmation(
"Are you sure you want to delete the migration '{0}' on target server '{1}', resource group '{2}'"
.format(migration_name, server_name, resource_group_name))
r = send_raw_request(
cmd.cli_ctx, "delete",
"https://management.azure.com/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{}/migrations/{}?api-version=2020-02-14-privatepreview"
.format(subscription_id, resource_group_name, server_name,
migration_name))
return r.json()
def validate_express_route_peering(cmd, namespace):
from msrestazure.tools import is_valid_resource_id, resource_id
circuit = namespace.circuit_name
peering = namespace.peering
if not circuit and not peering:
return
usage_error = CLIError(
'usage error: --peering ID | --peering NAME --circuit-name CIRCUIT')
if not is_valid_resource_id(peering):
namespace.peering = resource_id(
subscription=get_subscription_id(cmd.cli_ctx),
resource_group=namespace.resource_group_name,
namespace='Microsoft.Network',
type='expressRouteCircuits',
name=circuit,
child_type_1='peerings',
child_name_1=peering)
elif circuit:
raise usage_error
def _server_restore(cmd,
client,
resource_group_name,
server_name,
parameters,
no_wait=False,
**kwargs):
source_server = kwargs['source_server_id']
if not is_valid_resource_id(source_server):
if len(source_server.split('/')) == 1:
provider = 'Microsoft.DBForMySQL' if isinstance(
client, ServersOperations) else 'Microsoft.DBforPostgreSQL'
source_server = resource_id(subscription=get_subscription_id(
cmd.cli_ctx),
resource_group=resource_group_name,
namespace=provider,
type='servers',
name=source_server)
else:
raise ValueError(
'The provided source-server {} is invalid.'.format(
source_server))
parameters.properties.source_server_id = source_server
# Here is a workaround that we don't support cross-region restore currently,
# so the location must be set as the same as source server (not the resource group)
id_parts = parse_resource_id(source_server)
try:
source_server_object = client.get(id_parts['resource_group'],
id_parts['name'])
parameters.location = source_server_object.location
except Exception as e:
raise ValueError('Unable to get source server: {}.'.format(str(e)))
return client.create(resource_group_name,
server_name,
parameters,
raw=no_wait)
