def show_storage_account_usage(cmd, location): scf = storage_client_factory(cmd.cli_ctx) try: client = scf.usages except NotImplementedError: client = scf.usage return next((x for x in client.list_by_location(location) if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member
def create_storage_account(cmd, resource_group_name, account_name, sku=None, location=None, kind=None, tags=None, custom_domain=None, encryption_services=None, access_tier=None, https_only=None, bypass=None, default_action=None, assign_identity=False): StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \ cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity', 'Encryption', 'NetworkRuleSet') scf = storage_client_factory(cmd.cli_ctx) params = StorageAccountCreateParameters(sku=Sku(sku), kind=Kind(kind), location=location, tags=tags) if custom_domain: params.custom_domain = CustomDomain(custom_domain, None) if encryption_services: params.encryption = Encryption(services=encryption_services) if access_tier: params.access_tier = AccessTier(access_tier) if assign_identity: params.identity = Identity() if https_only: params.enable_https_traffic_only = https_only if NetworkRuleSet and (bypass or default_action): if bypass and not default_action: raise CLIError('incorrect usage: --default-action ACTION [--bypass SERVICE ...]') params.network_rule_set = NetworkRuleSet(bypass=bypass, default_action=default_action, ip_rules=None, virtual_network_rules=None) return scf.storage_accounts.create(resource_group_name, account_name, params)
def list_storage_accounts(cmd, resource_group_name=None): scf = storage_client_factory(cmd.cli_ctx) if resource_group_name: accounts = scf.storage_accounts.list_by_resource_group(resource_group_name) else: accounts = scf.storage_accounts.list() return list(accounts)
def show_storage_account_connection_string(cmd, resource_group_name, account_name, protocol='https', blob_endpoint=None, file_endpoint=None, queue_endpoint=None, table_endpoint=None, key_name='primary'): scf = storage_client_factory(cmd.cli_ctx) obj = scf.storage_accounts.list_keys(resource_group_name, account_name) # pylint: disable=no-member try: keys = [obj.keys[0].value, obj.keys[1].value] # pylint: disable=no-member except AttributeError: # Older API versions have a slightly different structure keys = [obj.key1, obj.key2] # pylint: disable=no-member endpoint_suffix = cmd.cli_ctx.cloud.suffixes.storage_endpoint connection_string = 'DefaultEndpointsProtocol={};EndpointSuffix={};AccountName={};AccountKey={}'.format( protocol, endpoint_suffix, account_name, keys[0] if key_name == 'primary' else keys[1]) # pylint: disable=no-member connection_string = '{}{}'.format( connection_string, ';BlobEndpoint={}'.format(blob_endpoint) if blob_endpoint else '') connection_string = '{}{}'.format( connection_string, ';FileEndpoint={}'.format(file_endpoint) if file_endpoint else '') connection_string = '{}{}'.format( connection_string, ';QueueEndpoint={}'.format(queue_endpoint) if queue_endpoint else '') connection_string = '{}{}'.format( connection_string, ';TableEndpoint={}'.format(table_endpoint) if table_endpoint else '') return {'connectionString': connection_string}
def show_storage_account_usage(cmd, location): scf = storage_client_factory(cmd.cli_ctx) try: client = scf.usages except NotImplementedError: client = scf.usage return next((x for x in client.list_by_location(location) if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member
def show_storage_account_connection_string(cmd, resource_group_name, account_name, protocol='https', blob_endpoint=None, file_endpoint=None, queue_endpoint=None, table_endpoint=None, key_name='primary'): scf = storage_client_factory(cmd.cli_ctx) obj = scf.storage_accounts.list_keys(resource_group_name, account_name) # pylint: disable=no-member try: keys = [obj.keys[0].value, obj.keys[1].value] # pylint: disable=no-member except AttributeError: # Older API versions have a slightly different structure keys = [obj.key1, obj.key2] # pylint: disable=no-member endpoint_suffix = cmd.cli_ctx.cloud.suffixes.storage_endpoint connection_string = 'DefaultEndpointsProtocol={};EndpointSuffix={};AccountName={};AccountKey={}'.format( protocol, endpoint_suffix, account_name, keys[0] if key_name == 'primary' else keys[1]) # pylint: disable=no-member connection_string = '{}{}'.format(connection_string, ';BlobEndpoint={}'.format(blob_endpoint) if blob_endpoint else '') connection_string = '{}{}'.format(connection_string, ';FileEndpoint={}'.format(file_endpoint) if file_endpoint else '') connection_string = '{}{}'.format(connection_string, ';QueueEndpoint={}'.format(queue_endpoint) if queue_endpoint else '') connection_string = '{}{}'.format(connection_string, ';TableEndpoint={}'.format(table_endpoint) if table_endpoint else '') return {'connectionString': connection_string}
def list_storage_accounts(cmd, resource_group_name=None): scf = storage_client_factory(cmd.cli_ctx) if resource_group_name: accounts = scf.storage_accounts.list_by_resource_group(resource_group_name) else: accounts = scf.storage_accounts.list() return list(accounts)
def create_storage_account(cmd, resource_group_name, account_name, sku=None, location=None, kind=None, tags=None, custom_domain=None, encryption_services=None, access_tier=None, https_only=None, bypass=None, default_action=None, assign_identity=False): StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \ cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity', 'Encryption', 'NetworkRuleSet') scf = storage_client_factory(cmd.cli_ctx) params = StorageAccountCreateParameters(sku=Sku(name=sku), kind=Kind(kind), location=location, tags=tags) if custom_domain: params.custom_domain = CustomDomain(name=custom_domain, use_sub_domain=None) if encryption_services: params.encryption = Encryption(services=encryption_services) if access_tier: params.access_tier = AccessTier(access_tier) if assign_identity: params.identity = Identity() if https_only: params.enable_https_traffic_only = https_only # temporary fix to allow idempotent create when value is None. (sdk defaults with False) params.is_hns_enabled = None if NetworkRuleSet and (bypass or default_action): if bypass and not default_action: from knack.util import CLIError raise CLIError('incorrect usage: --default-action ACTION [--bypass SERVICE ...]') params.network_rule_set = NetworkRuleSet(bypass=bypass, default_action=default_action, ip_rules=None, virtual_network_rules=None) return scf.storage_accounts.create(resource_group_name, account_name, params)
def _query_account_rg(cli_ctx, account_name): """Query the storage account's resource group, which the mgmt sdk requires.""" scf = storage_client_factory(cli_ctx) acc = next((x for x in scf.storage_accounts.list() if x.name == account_name), None) if acc: from msrestazure.tools import parse_resource_id return parse_resource_id(acc.id)['resource_group'], scf raise ValueError("Storage account '{}' not found.".format(account_name))
def create_storage_account(cmd, resource_group_name, account_name, sku=None, location=None, kind=None, tags=None, custom_domain=None, encryption_services=None, access_tier=None, https_only=None, enable_files_aadds=None, bypass=None, default_action=None, assign_identity=False): StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \ cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity', 'Encryption', 'NetworkRuleSet') scf = storage_client_factory(cmd.cli_ctx) logger.warning( "The default kind for created storage account will change to 'StorageV2' from 'Storage' in future" ) params = StorageAccountCreateParameters(sku=Sku(name=sku), kind=Kind(kind), location=location, tags=tags) if custom_domain: params.custom_domain = CustomDomain(name=custom_domain, use_sub_domain=None) if encryption_services: params.encryption = Encryption(services=encryption_services) if access_tier: params.access_tier = AccessTier(access_tier) if assign_identity: params.identity = Identity() if https_only: params.enable_https_traffic_only = https_only if enable_files_aadds is not None: AzureFilesIdentityBasedAuthentication = cmd.get_models( 'AzureFilesIdentityBasedAuthentication') params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication( directory_service_options='AADDS' if enable_files_aadds else 'None' ) if NetworkRuleSet and (bypass or default_action): if bypass and not default_action: from knack.util import CLIError raise CLIError( 'incorrect usage: --default-action ACTION [--bypass SERVICE ...]' ) params.network_rule_set = NetworkRuleSet(bypass=bypass, default_action=default_action, ip_rules=None, virtual_network_rules=None) return scf.storage_accounts.create(resource_group_name, account_name, params)
def create_storage_account_with_account_type(cmd, resource_group_name, account_name, account_type, location=None, tags=None): StorageAccountCreateParameters, AccountType = cmd.get_models( 'StorageAccountCreateParameters', 'AccountType') scf = storage_client_factory(cmd.cli_ctx) params = StorageAccountCreateParameters(location, AccountType(account_type), tags) return scf.storage_accounts.create(resource_group_name, account_name, params)
def create_storage_account(cmd, resource_group_name, account_name, sku=None, location=None, kind=None, tags=None, custom_domain=None, encryption_services=None, access_tier=None, https_only=None, enable_files_aadds=None, bypass=None, default_action=None, assign_identity=False, enable_large_file_share=None, enable_files_adds=None, domain_name=None, net_bios_domain_name=None, forest_name=None, domain_guid=None, domain_sid=None, azure_storage_sid=None, enable_hierarchical_namespace=None, encryption_key_type_for_table=None, encryption_key_type_for_queue=None, routing_choice=None, publish_microsoft_endpoints=None, publish_internet_endpoints=None): StorageAccountCreateParameters, Kind, Sku, CustomDomain, AccessTier, Identity, Encryption, NetworkRuleSet = \ cmd.get_models('StorageAccountCreateParameters', 'Kind', 'Sku', 'CustomDomain', 'AccessTier', 'Identity', 'Encryption', 'NetworkRuleSet') scf = storage_client_factory(cmd.cli_ctx) if kind is None: logger.warning("The default kind for created storage account will change to 'StorageV2' from 'Storage' " "in the future") params = StorageAccountCreateParameters(sku=Sku(name=sku), kind=Kind(kind), location=location, tags=tags) if custom_domain: params.custom_domain = CustomDomain(name=custom_domain, use_sub_domain=None) if encryption_services: params.encryption = Encryption(services=encryption_services) if access_tier: params.access_tier = AccessTier(access_tier) if assign_identity: params.identity = Identity() if https_only is not None: params.enable_https_traffic_only = https_only if enable_hierarchical_namespace is not None: params.is_hns_enabled = enable_hierarchical_namespace AzureFilesIdentityBasedAuthentication = cmd.get_models('AzureFilesIdentityBasedAuthentication') if enable_files_aadds is not None: params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication( directory_service_options='AADDS' if enable_files_aadds else 'None') if enable_files_adds is not None: from knack.util import CLIError ActiveDirectoryProperties = cmd.get_models('ActiveDirectoryProperties') if enable_files_adds: # enable AD if not (domain_name and net_bios_domain_name and forest_name and domain_guid and domain_sid and azure_storage_sid): raise CLIError("To enable ActiveDirectoryDomainServicesForFile, user must specify all of: " "--domain-name, --net-bios-domain-name, --forest-name, --domain-guid, --domain-sid and " "--azure_storage_sid arguments in Azure Active Directory Properties Argument group.") active_directory_properties = ActiveDirectoryProperties(domain_name=domain_name, net_bios_domain_name=net_bios_domain_name, forest_name=forest_name, domain_guid=domain_guid, domain_sid=domain_sid, azure_storage_sid=azure_storage_sid) # TODO: Enabling AD will automatically disable AADDS. Maybe we should throw error message params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication( directory_service_options='AD', active_directory_properties=active_directory_properties) else: # disable AD if domain_name or net_bios_domain_name or forest_name or domain_guid or domain_sid or azure_storage_sid: # pylint: disable=too-many-boolean-expressions raise CLIError("To disable ActiveDirectoryDomainServicesForFile, user can't specify any of: " "--domain-name, --net-bios-domain-name, --forest-name, --domain-guid, --domain-sid and " "--azure_storage_sid arguments in Azure Active Directory Properties Argument group.") params.azure_files_identity_based_authentication = AzureFilesIdentityBasedAuthentication( directory_service_options='None') if enable_large_file_share: LargeFileSharesState = cmd.get_models('LargeFileSharesState') params.large_file_shares_state = LargeFileSharesState("Enabled") if NetworkRuleSet and (bypass or default_action): if bypass and not default_action: from knack.util import CLIError raise CLIError('incorrect usage: --default-action ACTION [--bypass SERVICE ...]') params.network_rule_set = NetworkRuleSet(bypass=bypass, default_action=default_action, ip_rules=None, virtual_network_rules=None) if encryption_key_type_for_table is not None or encryption_key_type_for_queue is not None: EncryptionServices = cmd.get_models('EncryptionServices') EncryptionService = cmd.get_models('EncryptionService') params.encryption = Encryption() params.encryption.services = EncryptionServices() if encryption_key_type_for_table is not None: table_encryption_service = EncryptionService(enabled=True, key_type=encryption_key_type_for_table) params.encryption.services.table = table_encryption_service if encryption_key_type_for_queue is not None: queue_encryption_service = EncryptionService(enabled=True, key_type=encryption_key_type_for_queue) params.encryption.services.queue = queue_encryption_service if any([routing_choice, publish_microsoft_endpoints, publish_internet_endpoints]): RoutingPreference = cmd.get_models('RoutingPreference') params.routing_preference = RoutingPreference( routing_choice=routing_choice, publish_microsoft_endpoints=str2bool(publish_microsoft_endpoints), publish_internet_endpoints=str2bool(publish_internet_endpoints) ) return scf.storage_accounts.create(resource_group_name, account_name, params)
def get_storage_account_properties(cli_ctx, account_id): scf = storage_client_factory(cli_ctx) from msrestazure.tools import parse_resource_id result = parse_resource_id(account_id) return scf.storage_accounts.get_properties(result['resource_group'], result['name'])
def show_storage_account_usage_no_location(cmd): scf = storage_client_factory(cmd.cli_ctx) return next((x for x in scf.usage.list() if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member
def show_storage_account_usage_no_location(cmd): scf = storage_client_factory(cmd.cli_ctx) return next((x for x in scf.usage.list() if x.name.value == 'StorageAccounts'), None) # pylint: disable=no-member