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 _validator(cmd, namespace): from msrestazure.tools import is_valid_resource_id from knack.util import CLIError 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}-type TYPE [--{0}-parent PARENT] ' '[--{0}-namespace NAMESPACE]'.format(alias)) 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(cmd.cli_ctx), rg, res_ns, parent + '/' if parent else '', res_type, name_or_id)) del namespace.namespace del namespace.parent del namespace.resource_type if not preserve_resource_group_parameter: del namespace.resource_group_name
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 test_update_artifacts(self): result = _update_artifacts([], self.lab_resource_id) assert result == [] result = _update_artifacts([self.jdk_artifact], self.lab_resource_id) for artifact in result: assert is_valid_resource_id(artifact.get('artifact_id')) self.assertEqual('{}{}'.format(self.lab_resource_id, self.jdk_artifact.get('artifact_id')), artifact.get('artifact_id')) result = _update_artifacts([self.jdk_artifact, self.apt_get_artifact], self.lab_resource_id) for artifact in result: assert is_valid_resource_id(artifact.get('artifact_id')) result = _update_artifacts([self.full_artifact, self.apt_get_artifact], self.lab_resource_id) for artifact in result: assert is_valid_resource_id(artifact.get('artifact_id')) self.assertEqual(artifact.get('artifact_id'), self.full_artifact.get('artifact_id')) with self.assertRaises(CLIError): _update_artifacts({}, self.lab_resource_id) invalid_artifact = self.jdk_artifact del invalid_artifact['artifact_id'] with self.assertRaises(CLIError): _update_artifacts([invalid_artifact], self.lab_resource_id)
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 process_ag_listener_create_namespace(cmd, namespace): # pylint: disable=unused-argument from msrestazure.tools import is_valid_resource_id if namespace.frontend_ip and not is_valid_resource_id(namespace.frontend_ip): namespace.frontend_ip = _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'frontendIpConfigurations', namespace.frontend_ip) if namespace.frontend_port and not is_valid_resource_id(namespace.frontend_port): namespace.frontend_port = _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'frontendPorts', namespace.frontend_port) if namespace.ssl_cert and not is_valid_resource_id(namespace.ssl_cert): namespace.ssl_cert = _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'sslCertificates', namespace.ssl_cert)
def process_ag_url_path_map_rule_create_namespace(cmd, namespace): # pylint: disable=unused-argument from msrestazure.tools import is_valid_resource_id if namespace.address_pool and not is_valid_resource_id(namespace.address_pool): namespace.address_pool = _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'backendAddressPools', namespace.address_pool) if namespace.http_settings and not is_valid_resource_id(namespace.http_settings): namespace.http_settings = _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'backendHttpSettingsCollection', namespace.http_settings) if namespace.redirect_config and not is_valid_resource_id( namespace.redirect_config): namespace.redirect_config = _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'redirectConfigurations', namespace.redirect_config)
def validate_resource(cmd, namespace): # pylint: disable=unused-argument if namespace.resource: if not is_valid_resource_id(namespace.resource): if not namespace.namespace: raise CLIError('--namespace is required if --resource is not a resource ID.') if not namespace.resource_type: raise CLIError('--resource-type is required if --resource is not a resource ID.')
def get_storage_account_endpoint(cmd, storage_account, is_wasb): from ._client_factory import cf_storage from msrestazure.tools import parse_resource_id, is_valid_resource_id host = None if is_valid_resource_id(storage_account): parsed_storage_account = parse_resource_id(storage_account) resource_group_name = parsed_storage_account['resource_group'] storage_account_name = parsed_storage_account['resource_name'] storage_client = cf_storage(cmd.cli_ctx) storage_account = storage_client.storage_accounts.get_properties( resource_group_name=resource_group_name, account_name=storage_account_name) def extract_endpoint(storage_account, is_wasb): if not storage_account: return None return storage_account.primary_endpoints.dfs if not is_wasb else storage_account.primary_endpoints.blob def extract_host(uri): import re return uri and re.search('//(.*)/', uri).groups()[0] host = extract_host(extract_endpoint(storage_account, is_wasb)) return host
def parse_domain_name(domain): from msrestazure.tools import parse_resource_id, is_valid_resource_id domain_name = None if is_valid_resource_id(domain): parsed_domain_id = parse_resource_id(domain) domain_name = parsed_domain_id['resource_name'] return domain_name
def _use_custom_image(cli_ctx, namespace): """ Retrieve custom image from lab and update namespace """ from msrestazure.tools import is_valid_resource_id if is_valid_resource_id(namespace.image): namespace.custom_image_id = namespace.image else: custom_image_operation = get_devtestlabs_management_client(cli_ctx, None).custom_images odata_filter = ODATA_NAME_FILTER.format(namespace.image) custom_images = list(custom_image_operation.list(namespace.resource_group_name, namespace.lab_name, filter=odata_filter)) if not custom_images: err = "Unable to find custom image name '{}' in the '{}' lab.".format(namespace.image, namespace.lab_name) raise CLIError(err) elif len(custom_images) > 1: err = "Found more than 1 image with name '{}'. Please pick one from {}" raise CLIError(err.format(namespace.image, [x.name for x in custom_images])) else: namespace.custom_image_id = custom_images[0].id if custom_images[0].vm is not None: if custom_images[0].vm.windows_os_info is not None: os_type = "Windows" else: os_type = "Linux" elif custom_images[0].vhd is not None: os_type = custom_images[0].vhd.os_type else: raise CLIError("OS type cannot be inferred from the custom image {}".format(custom_images[0].id)) namespace.os_type = os_type
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 _validate_name_or_id( cli_ctx, resource_group_name, property_value, property_type, parent_value, parent_type): from azure.cli.core.commands.client_factory import get_subscription_id from msrestazure.tools import parse_resource_id, is_valid_resource_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(cli_ctx), child_name_1=property_value, child_type_1=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(cli_ctx)) value_supplied_was_id = False return (resource_id_parts, value_supplied_was_id)
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_applications(namespace): if namespace.resource_group_name: if isinstance(namespace.application, list): if len(namespace.application) == 1: if is_valid_resource_id(namespace.application[0]): raise CLIError("Specify either a full resource id or an application name and resource group.") else: raise CLIError("Resource group only allowed with a single application name.")
def validate_subnet(ns): from msrestazure.tools import is_valid_resource_id # vnet_name is depricated, using for backwards compatability if ns.vnet_name and not ns.vnet: ns.vnet = ns.vnet_name if not is_valid_resource_id(ns.subnet) and ((ns.vnet and not ns.subnet) or (ns.subnet and not ns.vnet)): raise CLIError('usage error: --vnet NAME --subnet NAME | --vnet ID --subnet NAME | --subnet 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 validate_express_route_port(cmd, namespace): from msrestazure.tools import is_valid_resource_id, resource_id if namespace.express_route_port and not is_valid_resource_id(namespace.express_route_port): namespace.express_route_port = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.Network', type='expressRoutePorts', name=namespace.express_route_port )
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 process_ag_http_settings_create_namespace(cmd, namespace): # pylint: disable=unused-argument from msrestazure.tools import is_valid_resource_id if namespace.probe and not is_valid_resource_id(namespace.probe): namespace.probe = _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'probes', namespace.probe) if namespace.auth_certs: def _validate_name_or_id(val): return val if is_valid_resource_id(val) else _generate_ag_subproperty_id( cmd.cli_ctx, namespace, 'authenticationCertificates', val) namespace.auth_certs = [_validate_name_or_id(x) for x in namespace.auth_certs]
def validate_virtual_hub(cmd, namespace): from msrestazure.tools import is_valid_resource_id, resource_id if namespace.virtual_hub and not is_valid_resource_id(namespace.virtual_hub): namespace.virtual_hub = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.Network', type='virtualHubs', name=namespace.virtual_hub )
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 get_arm_resource_by_id(cli_ctx, arm_id, api_version=None): from msrestazure.tools import parse_resource_id, is_valid_resource_id if not is_valid_resource_id(arm_id): raise CLIError("'{}' is not a valid ID.".format(arm_id)) client = get_mgmt_service_client(cli_ctx, ResourceType.MGMT_RESOURCE_RESOURCES) if not api_version: parts = parse_resource_id(arm_id) # to retrieve the provider, we need to know the namespace namespaces = {k: v for k, v in parts.items() if 'namespace' in k} # every ARM ID has at least one namespace, so start with that namespace = namespaces.pop('namespace') namespaces.pop('resource_namespace') # find the most specific child namespace (if any) and use that value instead highest_child = 0 for k, v in namespaces.items(): child_number = int(k.split('_')[2]) if child_number > highest_child: namespace = v highest_child = child_number # retrieve provider info for the namespace provider = client.providers.get(namespace) # assemble the resource type key used by the provider list operation. type1/type2/type3/... resource_type_str = '' if not highest_child: resource_type_str = parts['resource_type'] else: types = {int(k.split('_')[2]): v for k, v in parts.items() if k.startswith('child_type')} for k in sorted(types.keys()): if k < highest_child: continue resource_type_str = '{}{}/'.format(resource_type_str, parts['child_type_{}'.format(k)]) resource_type_str = resource_type_str.rstrip('/') api_version = None rt = next((t for t in provider.resource_types if t.resource_type.lower() == resource_type_str.lower()), None) if not rt: from azure.cli.core.parser import IncorrectUsageError raise IncorrectUsageError('Resource type {} not found.'.format(resource_type_str)) try: # if the service specifies, use the default API version api_version = rt.default_api_version except AttributeError: # if the service doesn't specify, use the most recent non-preview API version unless there is only a # single API version. API versions are returned by the service in a sorted list api_version = next((x for x in rt.api_versions if not x.endswith('preview')), rt.api_versions[0]) return client.resources.get_by_id(arm_id, api_version)
def validate_ddos_name_or_id(cmd, namespace): if namespace.ddos_protection_plan: from msrestazure.tools import is_valid_resource_id, resource_id if not is_valid_resource_id(namespace.ddos_protection_plan): namespace.ddos_protection_plan = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.Network', type='ddosProtectionPlans', name=namespace.ddos_protection_plan )
def validate_partner_namespace(cmd, namespace): from azure.cli.core.commands.client_factory import get_subscription_id from msrestazure.tools import is_valid_resource_id, resource_id if namespace.partner_namespace: if not is_valid_resource_id(namespace.partner_namespace): namespace.partner_namespace = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.ServiceBus', type='namespaces', name=namespace.partner_namespace)
def validate_target_listener(cmd, namespace): from msrestazure.tools import is_valid_resource_id, resource_id if namespace.target_listener and not is_valid_resource_id(namespace.target_listener): namespace.target_listener = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, name=namespace.application_gateway_name, namespace='Microsoft.Network', type='applicationGateways', child_type_1='httpListeners', child_name_1=namespace.target_listener)
def simple_validator(cmd, namespace): if namespace.network_security_group: # determine if network_security_group is name or ID is_id = is_valid_resource_id(namespace.network_security_group) if not is_id: namespace.network_security_group = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.Network', type='networkSecurityGroups', name=namespace.network_security_group)
def simple_validator(cmd, namespace): if namespace.virtual_network: # determine if vnet is name or ID is_id = is_valid_resource_id(namespace.virtual_network) if not is_id: namespace.virtual_network = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.Network', type='virtualNetworks', name=namespace.virtual_network)
def process_nw_flow_log_set_namespace(cmd, namespace): from msrestazure.tools import is_valid_resource_id, resource_id 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) process_nw_flow_log_show_namespace(cmd, namespace)
def validate_template_id(cmd, namespace): from msrestazure.tools import resource_id, is_valid_resource_id from azure.cli.core.commands.client_factory import get_subscription_id if not is_valid_resource_id(namespace.arm_template): if not namespace.artifact_source_name: raise CLIError("--artifact-source-name is required when name is " "provided for --arm-template") namespace.arm_template = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.DevTestLab', type='labs', name=namespace.lab_name, child_type_1='artifactSources', child_name_1=namespace.artifact_source_name, child_type_2='armTemplates', child_name_2=namespace.arm_template)
def validate_appservice_name_or_id(cmd, namespace): from azure.cli.core.commands.client_factory import get_subscription_id from msrestazure.tools import is_valid_resource_id, parse_resource_id if namespace.appservice_account: if not is_valid_resource_id(namespace.appservice_account): config_store_name = namespace.name if not config_store_name: config_store_name = get_store_name_from_connection_string( namespace.connection_string) resource_group, _ = resolve_resource_group(cmd, config_store_name) namespace.appservice_account = { "subscription": get_subscription_id(cmd.cli_ctx), "resource_group": resource_group, "name": namespace.appservice_account } else: namespace.appservice_account = parse_resource_id( namespace.appservice_account)
def _alert_rule_id(subscription, resource_group, alert): """ Transform alert rule name or ID to alert rule ID :param subscription: :param resource_group: :param alert: :return: alert rule ID """ if alert is None: return None from msrestazure.tools import resource_id, is_valid_resource_id if not is_valid_resource_id(alert): return resource_id(subscription=subscription, resource_group=resource_group, namespace='microsoft.insights', type='alertrules', name=alert) return alert
def convert_to_id(rule, key): if rule.get(key): ids = [] for p in rule.get(key): if isinstance(p, dict): ids.append( "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/applicationSecurityGroups/{2}" .format(self.subscription_id, p.get('resource_group'), p.get('name'))) elif isinstance(p, str): if is_valid_resource_id(p): ids.append(p) else: ids.append( "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/applicationSecurityGroups/{2}" .format(self.subscription_id, self.resource_group, p)) rule[key] = ids
def _validate_asg_name_or_id(namespace): subscription_id = get_subscription_id() 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='applicationSecurityGroups', name=val) ids.append(ApplicationSecurityGroup(id=val)) setattr(namespace, dest, ids)
def validate_subnet_id(cli_ctx, subnet, vnet_name, resource_group_name): from msrestazure.tools import is_valid_resource_id subnet_is_id = is_valid_resource_id(subnet) if subnet_is_id and not vnet_name: return subnet if subnet and not subnet_is_id and vnet_name: from msrestazure.tools import resource_id from azure.cli.core.commands.client_factory import get_subscription_id return resource_id(subscription=get_subscription_id(cli_ctx), resource_group=resource_group_name, namespace='Microsoft.Network', type='virtualNetworks', name=vnet_name, child_type_1='subnets', child_name_1=subnet) raise ArgumentUsageError( 'Usage error: --subnet ID | --subnet NAME --vnet-name NAME')
def validate_network_profile(cmd, ns): from azure.cli.core.commands.client_factory import get_subscription_id from msrestazure.tools import is_valid_resource_id, resource_id if ns.network_profile and ns.ip_address: raise CLIError( 'Can not use "--network-profile" with IP address type "Public".') if ns.network_profile and ns.dns_name_label: raise CLIError( 'Can not use "--network-profile" with "--dns-name-label".') if ns.network_profile: if not is_valid_resource_id(ns.network_profile): ns.network_profile = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=ns.resource_group_name, namespace='Microsoft.Network', type='networkProfiles', name=ns.network_profile)
def validate_disk_encryption_set(cmd, namespace): if namespace.disk_encryption_set is not None: if not is_valid_resource_id(namespace.disk_encryption_set): raise InvalidArgumentValueError( f"Invalid --disk-encryption-set '{namespace.disk_encryption_set}', has to be a resource ID." ) desid = parse_resource_id(namespace.disk_encryption_set) compute_client = get_mgmt_service_client(cmd.cli_ctx, ResourceType.MGMT_COMPUTE) try: compute_client.disk_encryption_sets.get( resource_group_name=desid['resource_group'], disk_encryption_set_name=desid['name']) except CloudError as err: raise InvalidArgumentValueError( f"Invald --disk-encryption-set, error when getting '{namespace.disk_encryption_set}':" f" {str(err)}") from err
def _generate_lb_id_list_from_names_or_ids(cli_ctx, namespace, prop, child_type): from msrestazure.tools import is_valid_resource_id raw = getattr(namespace, prop) if not raw: return raw = raw if isinstance(raw, list) else [raw] result = [] for item in raw: if is_valid_resource_id(item): result.append({'id': item}) else: if not namespace.load_balancer_name: raise CLIError('Unable to process {}. Please supply a well-formed ID or ' '--lb-name.'.format(item)) else: result.append({'id': _generate_lb_subproperty_id( cli_ctx, namespace, child_type, item)}) setattr(namespace, prop, result)
def process_nw_flow_log_show_namespace(cmd, namespace): from msrestazure.tools import is_valid_resource_id, resource_id, parse_resource_id if not is_valid_resource_id(namespace.nsg): namespace.nsg = resource_id( subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.Network', type='networkSecurityGroups', name=namespace.nsg) network_client = get_mgmt_service_client(cmd.cli_ctx, 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)(cmd, namespace)
def acr_create(cmd, client, registry_name, resource_group_name, sku, location=None, admin_enabled=False, default_action=None, tags=None, workspace=None, identity=None, key_encryption_key=None): if default_action and sku not in get_premium_sku(cmd): raise CLIError(NETWORK_RULE_NOT_SUPPORTED) if sku not in get_managed_sku(cmd): raise CLIError("Classic SKU is no longer supported. Please select a managed SKU.") Registry, Sku, NetworkRuleSet = cmd.get_models('Registry', 'Sku', 'NetworkRuleSet') registry = Registry(location=location, sku=Sku(name=sku), admin_user_enabled=admin_enabled, tags=tags) if default_action: registry.network_rule_set = NetworkRuleSet(default_action=default_action) if identity or key_encryption_key: _configure_cmk(cmd, registry, resource_group_name, identity, key_encryption_key) lro_poller = client.create(resource_group_name, registry_name, registry) if workspace: from msrestazure.tools import is_valid_resource_id, resource_id from azure.cli.core.commands import LongRunningOperation from azure.cli.core.commands.client_factory import get_subscription_id acr = LongRunningOperation(cmd.cli_ctx)(lro_poller) if not is_valid_resource_id(workspace): workspace = resource_id(subscription=get_subscription_id(cmd.cli_ctx), resource_group=resource_group_name, namespace='microsoft.OperationalInsights', type='workspaces', name=workspace) _create_diagnostic_settings(cmd.cli_ctx, acr, workspace) return acr return lro_poller
def flexible_replica_create(cmd, client, resource_group_name, replica_name, server_name, no_wait=False, location=None, sku_name=None, tier=None, **kwargs): provider = 'Microsoft.DBforMySQL' # set source server id if not is_valid_resource_id(server_name): if len(server_name.split('/')) == 1: server_name = resource_id(subscription=get_subscription_id( cmd.cli_ctx), resource_group=resource_group_name, namespace=provider, type='flexibleServers', name=server_name) else: raise CLIError('The provided source-server {} is invalid.'.format( server_name)) source_server_id_parts = parse_resource_id(server_name) 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))) location = source_server_object.location sku_name = source_server_object.sku.name tier = source_server_object.sku.tier parameters = mysql_flexibleservers.models.Server( sku=mysql_flexibleservers.models.Sku(name=sku_name, tier=tier), source_server_id=server_name, location=location, create_mode="Replica") return sdk_no_wait(no_wait, client.begin_create, resource_group_name, replica_name, parameters)
def sqlvm_aglistener_create(client, cmd, availability_group_listener_name, sql_virtual_machine_group_name, resource_group_name, availability_group_name, ip_address, subnet_resource_id, load_balancer_resource_id, probe_port, sql_virtual_machine_instances, port=1433, public_ip_address_resource_id=None, vnet_name=None): # pylint: disable=unused-argument ''' Creates an availability group listener ''' # Create the private ip address private_ip_object = PrivateIPAddress( ip_address=ip_address, subnet_resource_id=subnet_resource_id if is_valid_resource_id(subnet_resource_id) else None) # Create the load balancer configurations load_balancer_object = LoadBalancerConfiguration( private_ip_address=private_ip_object, public_ip_address_resource_id=public_ip_address_resource_id, load_balancer_resource_id=load_balancer_resource_id, probe_port=probe_port, sql_virtual_machine_instances=sql_virtual_machine_instances) # Create the availability group listener object ag_listener_object = AvailabilityGroupListener( availability_group_name=availability_group_name, load_balancer_configurations=[load_balancer_object], port=port) LongRunningOperation(cmd.cli_ctx)(sdk_no_wait( False, client.create_or_update, resource_group_name, sql_virtual_machine_group_name, availability_group_listener_name, ag_listener_object)) return client.get(resource_group_name, sql_virtual_machine_group_name, availability_group_listener_name)
def find_subscriptions_in_vm_with_msi(self, identity_id=None): import jwt from requests import HTTPError from msrestazure.azure_active_directory import MSIAuthentication from msrestazure.tools import is_valid_resource_id resource = self.cli_ctx.cloud.endpoints.active_directory_resource_id if identity_id: if is_valid_resource_id(identity_id): msi_creds = MSIAuthentication(resource=resource, msi_res_id=identity_id) identity_type = MsiAccountTypes.user_assigned_resource_id else: try: msi_creds = MSIAuthentication(resource=resource, client_id=identity_id) identity_type = MsiAccountTypes.user_assigned_client_id except HTTPError as ex: if ex.response.reason == 'Bad Request' and ex.response.status == 400: identity_type = MsiAccountTypes.user_assigned_object_id msi_creds = MSIAuthentication(resource=resource, object_id=identity_id) else: raise else: identity_type = MsiAccountTypes.system_assigned msi_creds = MSIAuthentication(resource=resource) token_entry = msi_creds.token token = token_entry['access_token'] logger.info('MSI: token was retrieved. Now trying to initialize local accounts...') decode = jwt.decode(token, verify=False, algorithms=['RS256']) tenant = decode['tid'] subscription_finder = SubscriptionFinder(self.cli_ctx, self.auth_ctx_factory, None) subscriptions = subscription_finder.find_from_raw_token(tenant, token) if not subscriptions: raise CLIError('No access was configured for the VM, hence no subscriptions were found') base_name = ('{}-{}'.format(identity_type, identity_id) if identity_id else identity_type) user = _USER_ASSIGNED_IDENTITY if identity_id else _SYSTEM_ASSIGNED_IDENTITY consolidated = self._normalize_properties(user, subscriptions, is_service_principal=True) for s in consolidated: s[_SUBSCRIPTION_NAME] = base_name # key-off subscription name to allow accounts with same id(but under different identities) self._set_subscriptions(consolidated, secondary_key_name=_SUBSCRIPTION_NAME) return deepcopy(consolidated)
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)
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) # name to resource id for virtual-network validate_network_id('custom_virtual_network_id')(cmd, namespace)
def flexible_replica_create(cmd, client, resource_group_name, server_name, source_server, no_wait=False, location=None, sku_name=None, tier=None, **kwargs): provider = 'Microsoft.DBforMySQL' # 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='flexibleServers', 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))) # if location is None: # location = source_server_object.location # if sku_name is None: # sku_name = source_server_object.sku.name # if tier is None: # tier = source_server_object.sku.tier location = source_server_object.location sku_name = source_server_object.sku.name tier = source_server_object.sku.tier # validation # sku_info = get_mysql_list_skus_info(cmd, location) # mysql_arguments_validator(tier, sku_name, None, None, sku_info) from azure.mgmt.rdbms import mysql_flexibleservers parameters = mysql_flexibleservers.models.Server( sku=mysql_flexibleservers.models.Sku(name=sku_name, tier=tier), source_server_id=source_server, location=location, create_mode="Replica") return sdk_no_wait(no_wait, client.create, resource_group_name, server_name, parameters)
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.begin_create(resource_group_name, name, cache_to_link.name, params)
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 get_vnet_validator(cmd, namespace): SubResource = cmd.get_models('SubResource') subscription_id = get_subscription_id(cmd.cli_ctx) resource_group = namespace.resource_group_name name_or_id = namespace.virtual_network if name_or_id is None: return if not is_valid_resource_id(name_or_id): name_or_id = resource_id( subscription=subscription_id, resource_group=resource_group, namespace='Microsoft.Network', type='virtualNetworks', name=name_or_id ) namespace.virtual_network = SubResource(id=name_or_id)
def validate_lab_vm_list(cmd, namespace): """ Validates parameters for lab vm list and updates namespace. """ from msrestazure.tools import resource_id, is_valid_resource_id collection = [namespace.filters, namespace.all, namespace.claimable] if _any(collection) and not _single(collection): raise CLIError("usage error: [--filters FILTER | [[--all | --claimable][--environment ENVIRONMENT]]") collection = [namespace.filters, namespace.environment] if _any(collection) and not _single(collection): raise CLIError("usage error: [--filters FILTER | [[--all | --claimable][--environment ENVIRONMENT]]") if namespace.filters: return # Retrieve all the vms of the lab if namespace.all: namespace.filters = None # Retrieve all the vms claimable by user elif namespace.claimable: namespace.filters = 'properties/allowClaim' # Default to retrieving users vms only else: # Find out owner object id if not namespace.object_id: namespace.filters = "Properties/ownerObjectId eq '{}'".format(_get_owner_object_id(cmd.cli_ctx)) if namespace.environment: if not is_valid_resource_id(namespace.environment): from azure.cli.core.commands.client_factory import get_subscription_id namespace.environment = resource_id(subscription=get_subscription_id(cmd.cli_ctx), resource_group=namespace.resource_group_name, namespace='Microsoft.DevTestLab', type='labs', name=namespace.lab_name, child_type_1='users', child_name_1=_get_owner_object_id(cmd.cli_ctx), child_type_2='environments', child_name_2=namespace.environment) if namespace.filters is None: namespace.filters = "Properties/environmentId eq '{}'".format(namespace.environment) else: namespace.filters = "{} and Properties/environmentId eq '{}'".format(namespace.filters, namespace.environment)
def _validate_resource_name(cmd, resource_id): if resource_id is None: return base_error_msg = "Technical resource argument {0} is invalid.".format( resource_id) if not is_valid_resource_id(resource_id): raise CLIError(base_error_msg) parsed_resource = parse_resource_id(resource_id) subid = parsed_resource["subscription"] if not _is_guid(subid): raise CLIError(base_error_msg + "Subscription id {0} is invalid.".format(subid)) session_subid = get_subscription_id(cmd.cli_ctx) if subid != session_subid: raise CLIError("{0} {1} does not match with {2}".format( base_error_msg, subid, session_subid))
def _validate_subnet(cmd, namespace): subnet = getattr(namespace, key) if not is_valid_resource_id(subnet): if not namespace.vnet: raise RequiredArgumentMissingError(f"Must specify --vnet if --{key.replace('_', '-')} is not an id.") validate_vnet(cmd, namespace) subnet = namespace.vnet + '/subnets/' + subnet setattr(namespace, key, subnet) parts = parse_resource_id(subnet) if parts['subscription'] != get_subscription_id(cmd.cli_ctx): raise InvalidArgumentValueError( f"--{key.replace('_', '-')} subscription '{parts['subscription']}' must equal cluster subscription.") if parts['namespace'].lower() != 'microsoft.network': raise InvalidArgumentValueError( f"--{key.replace('_', '-')} namespace '{parts['namespace']}' must equal Microsoft.Network.") if parts['type'].lower() != 'virtualnetworks': raise InvalidArgumentValueError( f"--{key.replace('_', '-')} type '{parts['type']}' must equal virtualNetworks.") if parts['last_child_num'] != 1: raise InvalidArgumentValueError(f"--{key.replace('_', '-')} '{subnet}' must have one child.") if 'child_namespace_1' in parts: raise InvalidArgumentValueError(f"--{key.replace('_', '-')} '{subnet}' must not have child namespace.") if parts['child_type_1'].lower() != 'subnets': raise InvalidArgumentValueError(f"--{key.replace('_', '-')} child type '{subnet}' must equal subnets.") client = get_mgmt_service_client( cmd.cli_ctx, ResourceType.MGMT_NETWORK) try: client.subnets.get(parts['resource_group'], parts['name'], parts['child_name_1']) except CloudError as err: raise InvalidArgumentValueError( f"Invald --{key.replace('_', '-')}, error when getting '{subnet}': {err.message}") from err
def process_nw_cm_v2_create_namespace(cmd, namespace): if namespace.location is None: # location is None only occurs in creating a V2 connection monitor endpoint_source_resource_id = namespace.endpoint_source_resource_id from msrestazure.tools import is_valid_resource_id, parse_resource_id from azure.mgmt.resource import ResourceManagementClient # parse and verify endpoint_source_resource_id if endpoint_source_resource_id is None: raise CLIError('usage error: ' '--location/--endpoint-source-resource-id is required to create a V2 connection monitor') if is_valid_resource_id(endpoint_source_resource_id) is False: raise CLIError('usage error: "{}" is not a valid resource id'.format(endpoint_source_resource_id)) resource = parse_resource_id(namespace.endpoint_source_resource_id) resource_client = get_mgmt_service_client(cmd.cli_ctx, ResourceManagementClient) resource_api_version = _resolve_api_version(resource_client, resource['namespace'], resource['resource_parent'], resource['resource_type']) resource = resource_client.resources.get_by_id(namespace.endpoint_source_resource_id, resource_api_version) namespace.location = resource.location if namespace.location is None: raise CLIError("Can not get location from --endpoint-source-resource-id") v2_required_parameter_set = ['endpoint_source_name', 'endpoint_dest_name', 'test_config_name'] for p in v2_required_parameter_set: if not hasattr(namespace, p) or getattr(namespace, p) is None: raise CLIError( 'usage error: --{} is required to create a V2 connection monitor'.format(p.replace('_', '-'))) if namespace.test_config_protocol is None: raise CLIError('usage error: --protocol is required to create a test configuration for V2 connection monitor') v2_optional_parameter_set = ['workspace_ids'] if namespace.output_type is not None: tmp = [p for p in v2_optional_parameter_set if getattr(namespace, p) is None] if v2_optional_parameter_set == tmp: raise CLIError('usage error: --output-type is specified but no other resource id provided') return get_network_watcher_from_location()(cmd, namespace)
def flexible_server_restore(cmd, client, resource_group_name, server_name, source_server, restore_point_in_time, location=None, no_wait=False): provider = 'Microsoft.DBforPostgreSQL' if not is_valid_resource_id(source_server): if len(source_server.split('/')) == 1: source_server_id = resource_id(subscription=get_subscription_id( cmd.cli_ctx), resource_group=resource_group_name, namespace=provider, type='flexibleServers', name=source_server) else: raise ValueError( 'The provided source-server {} is invalid.'.format( source_server)) else: source_server_id = source_server from azure.mgmt.rdbms import postgresql_flexibleservers parameters = postgresql_flexibleservers.models.Server( point_in_time_utc=restore_point_in_time, source_server_name= source_server, # this should be the source server name, not id create_mode="PointInTimeRestore", location=location) # Retrieve location from same location as source server id_parts = parse_resource_id(source_server_id) 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 sdk_no_wait(no_wait, client.create, resource_group_name, server_name, parameters)
def _get_image_reference(image, custom_image): """Returns image reference for the given image and custom image. :param str image or None: image alias or full spec. :param str custom_image or None: resource id of the custom image. :raise CLIError: if the image with given alias was not found. """ if custom_image and not image: raise CLIError('You need to specify --image argument with information about the custom image') if custom_image and not is_valid_resource_id(custom_image): raise CLIError('Ill-formed custom image resource id') if ':' in image: # full image specification is provided try: publisher, offer, sku, version = image.split(':') if not publisher: raise CLIError('Image publisher must be provided in --image argument') if not offer: raise CLIError('Image offer must be provided in --image argument') if not sku: raise CLIError('Image sku must be provided in --image argument') return models.ImageReference( publisher=publisher, offer=offer, sku=sku, version=version or None, virtual_machine_image_id=custom_image ) except ValueError: raise CLIError('--image must have format "publisher:offer:sku:version" or "publisher:offer:sku:"') # image alias is used reference = None for alias, value in SUPPORTED_IMAGE_ALIASES.items(): if alias.lower() == image.lower(): reference = value if not reference: raise CLIError('Unsupported image alias "{0}", supported aliases are {1}'.format( image, ', '.join(SUPPORTED_IMAGE_ALIASES.keys()))) result = copy.deepcopy(reference) result.virtual_machine_image_id = custom_image return result
def internal_validate_lock_parameters(namespace, resource_group, resource_provider_namespace, parent_resource_path, resource_type, resource_name): if resource_group is None: if resource_name is not None: from msrestazure.tools import parse_resource_id, is_valid_resource_id if not is_valid_resource_id(resource_name): raise CLIError('--resource is not a valid resource ID. ' '--resource as a resource name is ignored if --resource-group is not given.') # resource-name is an ID, populate namespace id_dict = parse_resource_id(resource_name) for id_part in ['resource_name', 'resource_type', 'resource_group']: setattr(namespace, id_part, id_dict.get(id_part)) setattr(namespace, 'resource_provider_namespace', id_dict.get('resource_namespace')) setattr(namespace, 'parent_resource_path', id_dict.get('resource_parent').strip('/')) if resource_type is not None: raise CLIError('--resource-type is ignored if --resource-group is not given.') if resource_provider_namespace is not None: raise CLIError('--namespace is ignored if --resource-group is not given.') if parent_resource_path is not None: raise CLIError('--parent is ignored if --resource-group is not given.') return if resource_name is None: if resource_type is not None: raise CLIError('--resource-type is ignored if --resource is not given.') if resource_provider_namespace is not None: raise CLIError('--namespace is ignored if --resource is not given.') if parent_resource_path is not None: raise CLIError('--parent is ignored if --resource is not given.') return if not resource_type: raise CLIError('--resource-type is required if the name, --resource, is present') parts = resource_type.split('/') if resource_provider_namespace is None: if len(parts) == 1: raise CLIError('A resource namespace is required if the name, --resource, is present.' 'Expected <namespace>/<type> or --namespace=<namespace>') elif len(parts) != 1: raise CLIError('Resource namespace specified in both --resource-type and --namespace')
def flexible_server_restore(cmd, client, resource_group_name, server_name, source_server, restore_point_in_time, location=None, no_wait=False): provider = 'Microsoft.DBforMySQL' validate_server_name( cf_mysql_check_resource_availability(cmd.cli_ctx, '_'), server_name, 'Microsoft.DBforMySQL/flexibleServers') 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='flexibleServers', name=source_server) else: raise ValueError( 'The provided source-server {} is invalid.'.format( source_server)) parameters = mysql_flexibleservers.models.Server( source_server_id=source_server, restore_point_in_time=restore_point_in_time, location=location, create_mode="PointInTimeRestore") # Retrieve location from same location as source server 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 sdk_no_wait(no_wait, client.begin_create, resource_group_name, server_name, parameters)
def get_key_for_storage_account(cmd, storage_account): # pylint: disable=unused-argument from ._client_factory import cf_storage from msrestazure.tools import parse_resource_id, is_valid_resource_id from knack.util import CLIError storage_account_key = None if is_valid_resource_id(storage_account): parsed_storage_account = parse_resource_id(storage_account) resource_group_name = parsed_storage_account['resource_group'] storage_account_name = parsed_storage_account['resource_name'] storage_client = cf_storage(cmd.cli_ctx) keys = storage_client.storage_accounts.list_keys( resource_group_name, storage_account_name) storage_account_key = keys.keys[0].value # pylint: disable=no-member elif storage_account: raise CLIError( 'Failed to get access key for storage account: {}'.format( storage_account)) return storage_account_key
def _verify_subnet(client, subnet, nfs_name, nfs_resource_group): if not subnet: return if not is_valid_resource_id(subnet): raise CLIError('Ill-formed subnet resource id') # check there are no conflicts between provided subnet and mounted nfs if not nfs_name: return nfs = None # type: models.FileServer try: nfs = client.file_servers.get(nfs_name, nfs_resource_group) except CloudError as e: if e.status_code != 404: raise if not nfs: # CLI will return the error during nfs validation return if nfs.subnet.id != subnet: raise CLIError('Cluster and mounted NFS must be in the same subnet.')