Lines Matching refs:namespace
73 def parse_storage_account(cmd, namespace): argument
77 if namespace.account_name and is_valid_resource_id(namespace.account_name):
78 namespace.resource_group_name = parse_resource_id(namespace.account_name)['resource_group']
79 namespace.account_name = parse_resource_id(namespace.account_name)['name']
80 elif namespace.account_name and not is_valid_resource_id(namespace.account_name) and \
81 not namespace.resource_group_name:
82 namespace.resource_group_name = _query_account_rg(cmd.cli_ctx, namespace.account_name)[0]
85 def process_resource_group(cmd, namespace): argument
87 if namespace.account_name and not namespace.resource_group_name:
88 namespace.resource_group_name = _query_account_rg(cmd.cli_ctx, namespace.account_name)[0]
91 def validate_table_payload_format(cmd, namespace): argument
93 if namespace.accept:
99 namespace.accept = formats[namespace.accept.lower()]
102 def validate_bypass(namespace): argument
103 if namespace.bypass:
104 …namespace.bypass = ', '.join(namespace.bypass) if isinstance(namespace.bypass, list) else namespac…
107 def validate_hns_migration_type(namespace): argument
108 if namespace.request_type and namespace.request_type.lower() == 'validation':
109 namespace.request_type = 'HnsOnValidationRequest'
110 if namespace.request_type and namespace.request_type.lower() == 'upgrade':
111 namespace.request_type = 'HnsOnHydrationRequest'
123 def validate_client_parameters(cmd, namespace): argument
126 n = namespace
205 def validate_encryption_key(cmd, namespace): argument
207 if namespace.key_source == encryption_key_source.microsoft_key_vault and \
208 not namespace.key_uri:
211 if namespace.key_source != encryption_key_source.microsoft_key_vault and namespace.key_uri:
216 def process_blob_source_uri(cmd, namespace): argument
227 ns = vars(namespace)
248 validate_client_parameters(cmd, namespace) # must run first to resolve storage account
290 namespace.copy_source = uri
293 def validate_source_uri(cmd, namespace): # pylint: disable=too-many-statements argument
304 ns = vars(namespace)
331 namespace.copy_source = uri
344 validate_client_parameters(cmd, namespace) # must run first to resolve storage account
394 namespace.copy_source = uri
397 def validate_source_url(cmd, namespace): # pylint: disable=too-many-statements, too-many-locals argument
410 ns = vars(namespace)
437 namespace.copy_source = uri
450 validate_client_parameters(cmd, namespace) # must run first to resolve storage account
508 namespace.source_url = uri
511 def validate_blob_type(namespace): argument
512 if not namespace.blob_type:
513 namespace.blob_type = 'page' if namespace.file_path.endswith('.vhd') else 'block'
516 def validate_storage_data_plane_list(namespace): argument
517 if namespace.num_results == '*':
518 namespace.num_results = None
520 namespace.num_results = int(namespace.num_results)
527 def validator(cmd, namespace): argument
536 validate_client_parameters(cmd, namespace)
538 get_file_path_validator()(namespace)
539 ns = vars(namespace)
592 def validate_custom_domain(namespace): argument
593 if namespace.use_subdomain and not namespace.custom_domain:
597 def validate_encryption_services(cmd, namespace): argument
601 if namespace.encryption_services:
604 …services = {service: t_encryption_service(enabled=True) for service in namespace.encryption_servic…
606 namespace.encryption_services = t_encryption_services(**services)
609 def validate_encryption_source(namespace): argument
610 if namespace.encryption_key_source == 'Microsoft.Keyvault' and \
611 not (namespace.encryption_key_name and namespace.encryption_key_vault):
615 …if namespace.encryption_key_name or namespace.encryption_key_version is not None or namespace.encr…
616 … if namespace.encryption_key_source and namespace.encryption_key_source != 'Microsoft.Keyvault':
621 def validate_entity(namespace): argument
624 values = dict(x.split('=', 1) for x in namespace.entity)
659 namespace.entity = values
662 def validate_marker(namespace): argument
665 if not namespace.marker:
667 marker = dict(x.split('=', 1) for x in namespace.marker)
681 namespace.marker = marker
688 def validator(namespace): argument
689 if not hasattr(namespace, 'path'):
692 path = namespace.path
697 file_name = os.path.split(getattr(namespace, default_file_param))[1]
699 namespace.directory_name = dir_name
700 namespace.file_name = file_name
701 del namespace.path
706 def validate_included_datasets(cmd, namespace): argument
707 if namespace.include:
708 include = namespace.include
713 …namespace.include = t_blob_include('s' in include, 'm' in include, False, 'c' in include, 'd' in i…
731 def validator(namespace): argument
732 if namespace.include:
733 if set(namespace.include) - set(allowed_string):
738 if 's' in namespace.include:
740 if 'm' in namespace.include:
742 if 'c' in namespace.include:
744 if 'd' in namespace.include:
746 if 'v' in namespace.include:
748 if 't' in namespace.include:
750 namespace.include = include
755 def validate_key_name(namespace): argument
757 if hasattr(namespace, 'key_type') and namespace.key_type:
758 namespace.key_name = namespace.key_type + key_options[namespace.key_name]
760 namespace.key_name = storage_account_key_options[namespace.key_name]
761 if hasattr(namespace, 'key_type'):
762 del namespace.key_type
765 def validate_metadata(namespace): argument
766 if namespace.metadata:
767 namespace.metadata = dict(x.split('=', 1) for x in namespace.metadata)
797 def validator(namespace): argument
798 if namespace.permission:
799 if set(namespace.permission) - set(allowed_string):
804 namespace.permission = permission_class.from_string(namespace.permission)
806 namespace.permission = permission_class(_str=namespace.permission)
811 def table_permission_validator(cmd, namespace): argument
814 if namespace.permission:
815 if set(namespace.permission) - set('raud'):
818 namespace.permission = t_table_permissions(_str=namespace.permission)
821 def validate_container_public_access(cmd, namespace): argument
825 if namespace.public_access:
826 … namespace.public_access = get_container_access_type(cmd.cli_ctx, namespace.public_access.lower())
828 if hasattr(namespace, 'signed_identifiers'):
831 ns = vars(namespace)
832 validate_client_parameters(cmd, namespace)
843 def validate_container_nfsv3_squash(cmd, namespace): argument
845 if namespace.root_squash and namespace.root_squash == t_root_squash.NO_ROOT_SQUASH:
846 namespace.enable_nfs_v3_root_squash = False
847 namespace.enable_nfs_v3_all_squash = False
848 elif namespace.root_squash and namespace.root_squash == t_root_squash.ROOT_SQUASH:
849 namespace.enable_nfs_v3_root_squash = True
850 namespace.enable_nfs_v3_all_squash = False
851 elif namespace.root_squash and namespace.root_squash == t_root_squash.ALL_SQUASH:
852 namespace.enable_nfs_v3_all_squash = True
854 del namespace.root_squash
857 def validate_fs_public_access(cmd, namespace): argument
860 if namespace.public_access:
861 namespace.public_access = get_fs_access_type(cmd.cli_ctx, namespace.public_access.lower())
864 def validate_select(namespace): argument
865 if namespace.select:
866 namespace.select = ','.join(namespace.select)
870 def get_source_file_or_blob_service_client(cmd, namespace): argument
886 ns = vars(namespace)
963 def add_progress_callback(cmd, namespace): argument
976 if not namespace.no_progress:
977 namespace.progress_callback = _update_progress
978 del namespace.no_progress
981 def process_container_delete_parameters(cmd, namespace): argument
984 if namespace.bypass_immutability_policy:
986 namespace.processed_account_name = namespace.account_name
987 namespace.processed_resource_group, namespace.mgmt_client = _query_account_rg(
988 cmd.cli_ctx, namespace.account_name)
989 del namespace.auth_mode
992 validate_client_parameters(cmd, namespace)
995 def process_blob_download_batch_parameters(cmd, namespace): argument
998 if not os.path.exists(namespace.destination) or not os.path.isdir(namespace.destination):
1002 _process_blob_batch_container_parameters(cmd, namespace)
1005 add_progress_callback(cmd, namespace)
1008 def process_blob_upload_batch_parameters(cmd, namespace): argument
1011 if not os.path.exists(namespace.source) or not os.path.isdir(namespace.source):
1015 _process_blob_batch_container_parameters(cmd, namespace, source=False)
1018 namespace.source = os.path.realpath(namespace.source)
1019 namespace.source_files = list(glob_files_locally(namespace.source, namespace.pattern))
1022 if namespace.blob_type is None:
1023 vhd_files = [f for f in namespace.source_files if f[0].endswith('.vhd')]
1024 if any(vhd_files) and len(vhd_files) == len(namespace.source_files):
1026 namespace.blob_type = 'page'
1034 namespace.blob_type = 'block'
1037 validate_metadata(namespace)
1039 get_content_setting_validator(t_blob_content_settings, update=False)(cmd, namespace)
1040 add_progress_callback(cmd, namespace)
1043 def process_blob_delete_batch_parameters(cmd, namespace): argument
1044 _process_blob_batch_container_parameters(cmd, namespace)
1047 def _process_blob_batch_container_parameters(cmd, namespace, source=True): argument
1057 container_arg_val = getattr(namespace, container_arg) # either a url or name
1061 setattr(namespace, container_name_arg, container_arg_val)
1065 setattr(namespace, container_name_arg, identifier.container)
1066 if namespace.account_name is None:
1067 namespace.account_name = identifier.account_name
1068 elif namespace.account_name != identifier.account_name:
1073 if not namespace.sas_token and identifier.sas_token:
1074 namespace.sas_token = identifier.sas_token
1077 validate_client_parameters(cmd, namespace)
1080 def process_file_upload_batch_parameters(cmd, namespace): argument
1083 if not os.path.exists(namespace.source):
1084 raise ValueError('incorrect usage: source {} does not exist'.format(namespace.source))
1086 if not os.path.isdir(namespace.source):
1091 identifier = StorageResourceIdentifier(cmd.cli_ctx.cloud, namespace.destination)
1096 namespace.destination = identifier.share
1098 if not namespace.account_name:
1099 namespace.account_name = identifier.account_name
1101 namespace.source = os.path.realpath(namespace.source)
1104 def process_file_download_batch_parameters(cmd, namespace): argument
1107 if not os.path.exists(namespace.destination) or not os.path.isdir(namespace.destination):
1111 process_file_batch_source_parameters(cmd, namespace)
1114 def process_file_batch_source_parameters(cmd, namespace): argument
1116 identifier = StorageResourceIdentifier(cmd.cli_ctx.cloud, namespace.source)
1121 namespace.source = identifier.share
1123 if not namespace.account_name:
1124 namespace.account_name = identifier.account_name
1127 def process_file_download_namespace(namespace): argument
1128 get_file_path_validator()(namespace)
1130 dest = namespace.file_path
1132 namespace.file_path = os.path.join(dest, namespace.file_name) \
1133 if dest else namespace.file_name
1136 def process_metric_update_namespace(namespace): argument
1137 namespace.hour = namespace.hour == 'true'
1138 namespace.minute = namespace.minute == 'true'
1139 namespace.api = namespace.api == 'true' if namespace.api else None
1140 if namespace.hour is None and namespace.minute is None:
1143 if (namespace.hour or namespace.minute) and namespace.api is None:
1148 def validate_subnet(cmd, namespace): argument
1152 subnet = namespace.subnet
1154 vnet = namespace.vnet_name
1159 namespace.subnet = resource_id(
1161 resource_group=namespace.resource_group_name,
1162 namespace='Microsoft.Network',
1246 def _validator(namespace): argument
1247 service_types = set(getattr(namespace, property_name, list()))
1256 setattr(namespace, property_name, service_types)
1261 def page_blob_tier_validator(cmd, namespace): argument
1262 if not namespace.tier:
1265 if namespace.blob_type != 'page' and namespace.tier:
1270 namespace.tier = getattr(cmd.get_models('_models#PremiumPageBlobTier'), namespace.tier)
1272 … namespace.tier = getattr(cmd.get_models('blob.models#PremiumPageBlobTier'), namespace.tier)
1279 def block_blob_tier_validator(cmd, namespace): argument
1280 if not namespace.tier:
1283 if namespace.blob_type != 'block' and namespace.tier:
1288 namespace.tier = getattr(cmd.get_models('_models#StandardBlobTier'), namespace.tier)
1290 namespace.tier = getattr(cmd.get_models('blob.models#StandardBlobTier'), namespace.tier)
1297 def blob_tier_validator(cmd, namespace): argument
1298 if namespace.blob_type == 'page':
1299 page_blob_tier_validator(cmd, namespace)
1300 elif namespace.blob_type == 'block':
1301 block_blob_tier_validator(cmd, namespace)
1306 def blob_download_file_path_validator(namespace): argument
1307 if os.path.isdir(namespace.file_path):
1309 … raise FileOperationError('File is expected, not a directory: {}'.format(namespace.file_path))
1312 def blob_rehydrate_priority_validator(namespace): argument
1313 if namespace.blob_type == 'page' and namespace.rehydrate_priority:
1315 if namespace.tier == 'Archive' and namespace.rehydrate_priority:
1317 if namespace.rehydrate_priority is None:
1318 namespace.rehydrate_priority = 'Standard'
1321 def validate_azcopy_upload_destination_url(cmd, namespace): argument
1323 'account_name': namespace.account_name, 'connection_string': namespace.connection_string})
1324 destination_path = namespace.destination_path
1327 url = client.make_blob_url(namespace.destination_container, destination_path)
1328 namespace.destination = url
1329 del namespace.destination_container
1330 del namespace.destination_path
1333 def validate_azcopy_remove_arguments(cmd, namespace): argument
1339 ns = vars(namespace)
1360 'account_name': namespace.account_name})
1364 namespace.service = 'blob'
1365 namespace.target = url
1369 'account_name': namespace.account_name,
1370 'account_key': namespace.account_key})
1374 namespace.service = 'file'
1375 namespace.target = url
1378 def as_user_validator(namespace): argument
1379 if hasattr(namespace, 'token_credential') and not namespace.as_user:
1381 if namespace.as_user:
1382 if namespace.expiry is None:
1386 expiry = get_datetime_type(False)(namespace.expiry)
1393 if ((not hasattr(namespace, 'token_credential') or namespace.token_credential is None) and
1394 (not hasattr(namespace, 'auth_mode') or namespace.auth_mode != 'login')):
1399 def validator_change_feed_retention_days(namespace): argument
1400 enable = namespace.enable_change_feed
1401 days = namespace.change_feed_retention_days
1421 def validator_delete_retention_days(namespace, enable=None, days=None): argument
1424 enable = getattr(namespace, enable)
1425 days = getattr(namespace, days)
1450 def validate_container_delete_retention_days(namespace): argument
1451 validator_delete_retention_days(namespace, enable='enable_container_delete_retention',
1455 def validate_delete_retention_days(namespace): argument
1456 validator_delete_retention_days(namespace, enable='enable_delete_retention',
1460 def validate_file_delete_retention_days(namespace): argument
1462 if namespace.enable_delete_retention is True and namespace.delete_retention_days is None:
1467 if namespace.enable_delete_retention is False and namespace.delete_retention_days is not None:
1474 def __call__(self, parser, namespace, values, option_string=None): argument
1475 if not namespace.blob_ranges:
1476 namespace.blob_ranges = []
1479 … BlobRange = namespace._cmd.get_models('BlobRestoreRange', resource_type=ResourceType.MGMT_STORAGE)
1484 namespace.blob_ranges.append(BlobRange(
1490 def validate_private_endpoint_connection_id(cmd, namespace): argument
1491 if namespace.connection_id:
1493 result = parse_proxy_resource_id(namespace.connection_id)
1494 namespace.resource_group_name = result['resource_group']
1495 namespace.account_name = result['name']
1496 namespace.private_endpoint_connection_name = result['child_name_1']
1498 if namespace.account_name and not namespace.resource_group_name:
1499 namespace.resource_group_name = _query_account_rg(cmd.cli_ctx, namespace.account_name)[0]
1501 …if not all([namespace.account_name, namespace.resource_group_name, namespace.private_endpoint_conn…
1504 del namespace.connection_id
1541 def validate_access_control(namespace): argument
1542 if namespace.acl and namespace.permissions:
1555 def validate_logging_version(namespace): argument
1556 …if validate_service_type(namespace.services, 'table') and namespace.version and namespace.version …
1562 def validate_match_condition(namespace): argument
1564 if namespace.if_match:
1565 namespace = _if_match(if_match=namespace.if_match, **namespace)
1566 del namespace.if_match
1567 if namespace.if_none_match:
1568 namespace = _if_none_match(if_none_match=namespace.if_none_match, **namespace)
1569 del namespace.if_none_match
1572 def validate_or_policy(cmd, namespace): argument
1576 if namespace.properties is None:
1578 if namespace.source_account is None:
1582 if namespace.destination_account is None:
1583 namespace.destination_account = namespace.account_name
1590 if os.path.exists(namespace.properties):
1591 or_policy = get_file_json(namespace.properties)
1593 or_policy = shell_safe_json_parse(namespace.properties)
1596 namespace.source_account = or_policy["sourceAccount"]
1598 namespace.source_account = or_policy["source_account"]
1599 if namespace.source_account is None:
1603 namespace.destination_account = or_policy["destinationAccount"]
1605 namespace.destination_account = or_policy["destination_account"]
1614 namespace.properties = or_policy
1617 namespace.policy_id = or_policy['policyId']
1619 if not is_valid_resource_id(namespace.source_account):
1620 namespace.source_account = resource_id(
1622 resource_group=namespace.resource_group_name,
1623 namespace='Microsoft.Storage', type='storageAccounts',
1624 name=namespace.source_account)
1625 if not is_valid_resource_id(namespace.destination_account):
1626 namespace.destination_account = resource_id(
1628 resource_group=namespace.resource_group_name,
1629 namespace='Microsoft.Storage', type='storageAccounts',
1630 name=namespace.destination_account)
1633 def get_url_with_sas(cmd, namespace, url=None, container=None, blob=None, share=None, file_path=Non… argument
1658 namespace.account_name = storage_info[0]
1669 validate_client_parameters(cmd, namespace)
1670 kwargs = {'account_name': namespace.account_name,
1671 'account_key': namespace.account_key,
1672 'connection_string': namespace.connection_string,
1673 'sas_token': namespace.sas_token}
1689 url = 'https://{}.{}.{}'.format(namespace.account_name, service, storage_endpoint)
1722 def validate_azcopy_credential(cmd, namespace): argument
1724 if not _is_valid_uri(namespace.destination):
1725 namespace.url = namespace.destination
1726 service, namespace.destination = get_url_with_sas(
1727 cmd, namespace, url=namespace.destination,
1728 container=namespace.destination_container, blob=namespace.destination_blob,
1729 share=namespace.destination_share, file_path=namespace.destination_file_path)
1730 …namespace.destination = _add_sas_for_url(cmd, url=namespace.destination, account_name=namespace.ac…
1731 … account_key=namespace.account_key, sas_token=namespace.sas_token,
1734 if not _is_valid_uri(namespace.source):
1736 …if not namespace.source_account_key and not namespace.source_sas and not namespace.source_connecti…
1737 if namespace.source_account_name == namespace.account_name:
1738 namespace.source_account_key = namespace.account_key
1739 namespace.source_sas = namespace.sas_token
1740 namespace.source_connection_string = namespace.connection_string
1741 namespace.account_name = namespace.source_account_name
1742 namespace.account_key = namespace.source_account_key
1743 namespace.sas_token = namespace.source_sas
1744 namespace.connection_string = namespace.source_connection_string
1747 namespace.url = namespace.source
1748 service, namespace.source = get_url_with_sas(
1749 cmd, namespace, url=namespace.source,
1750 container=namespace.source_container, blob=namespace.source_blob,
1751 share=namespace.source_share, file_path=namespace.source_file_path)
1752 …namespace.source = _add_sas_for_url(cmd, url=namespace.source, account_name=namespace.account_name,
1753 … account_key=namespace.account_key, sas_token=namespace.sas_token,
1761 def validate_fs_directory_upload_destination_url(cmd, namespace): argument
1762 kwargs = {'account_name': namespace.account_name,
1763 'account_key': namespace.account_key,
1764 'connection_string': namespace.connection_string,
1765 'sas_token': namespace.sas_token,
1766 'file_system_name': namespace.destination_fs}
1769 if namespace.destination_path:
1772 file_client = client.get_file_client(file_path=namespace.destination_path)
1785 namespace.destination = url
1787 namespace.destination = _add_sas_for_url(cmd, url=url, account_name=namespace.account_name,
1788 … account_key=namespace.account_key, sas_token=namespace.sas_token,
1790 del namespace.destination_fs
1791 del namespace.destination_path
1794 def validate_fs_directory_download_source_url(cmd, namespace): argument
1795 kwargs = {'account_name': namespace.account_name,
1796 'account_key': namespace.account_key,
1797 'connection_string': namespace.connection_string,
1798 'sas_token': namespace.sas_token,
1799 'file_system_name': namespace.source_fs}
1802 if namespace.source_path:
1803 file_client = client.get_file_client(file_path=namespace.source_path)
1806 namespace.source = url
1808 namespace.source = _add_sas_for_url(cmd, url=url, account_name=namespace.account_name,
1809 … account_key=namespace.account_key, sas_token=namespace.sas_token,
1811 del namespace.source_fs
1812 del namespace.source_path
1843 def add_acl_progress_hook(namespace): argument
1844 if namespace.progress_hook:
1855 namespace.progress_hook = progress_callback
1859 def validate_not_none(cmd, namespace): argument
1860 attribute = getattr(namespace, attribute_name, None)
1868 def validate_policy(namespace): argument
1869 if namespace.id is not None:
1874 def validate_immutability_arguments(namespace): argument
1876 if not namespace.enable_alw:
1877 if any([namespace.immutability_period_since_creation_in_days,
1878 … namespace.immutability_policy_state, namespace.allow_protected_append_writes is not None]):
1886 def validate_allow_protected_append_writes_all(namespace): argument
1888 if namespace.allow_protected_append_writes_all and namespace.allow_protected_append_writes:
1897 def validate_blob_name_for_upload(namespace): argument
1898 if not namespace.blob_name:
1899 namespace.blob_name = os.path.basename(namespace.file_path)