def _get_files_from_afs(cli_ctx, afs, path, expiry):
"""Returns a list of files and directories under given path on mounted Azure File share.
:param models.AzureFileShareReference afs: Azure file share reference.
:param str path: path to list files from.
:param int expiry: SAS expiration time in minutes.
"""
from azure.storage.file import FileService
from azure.storage.file.models import File, FilePermissions
result = []
service = FileService(afs.account_name, _get_storage_account_key(cli_ctx, afs.account_name, None))
share_name = afs.azure_file_url.split('/')[-1]
effective_path = _get_path_for_storage(path)
if not service.exists(share_name, effective_path):
return result
for f in service.list_directories_and_files(share_name, effective_path):
if isinstance(f, File):
sas = service.generate_file_shared_access_signature(
share_name, effective_path, f.name, permission=FilePermissions(read=True),
expiry=datetime.datetime.utcnow() + datetime.timedelta(minutes=expiry))
result.append(
LogFile(
f.name, service.make_file_url(share_name, effective_path, f.name, 'https', sas),
False, f.properties.content_length))
else:
result.append(LogFile(f.name, None, True, None))
return result
def create_snapshot(file_share, directory_name, file_name, container_name, correlation_guid = str(uuid.uuid4())):
file_service = FileService(account_name=STORAGE_ACCOUNT_NAME, account_key=STORAGE_ACCOUNT_KEY)
blob_service = BlockBlobService(account_name=STORAGE_ACCOUNT_NAME, account_key=STORAGE_ACCOUNT_KEY)
file_sas_token = file_service.generate_file_shared_access_signature(
file_share,
directory_name,
file_name,
permission = FilePermissions.READ,
expiry = datetime.now() + timedelta(minutes = 10))
file_url = file_service.make_file_url(file_share, directory_name, file_name, sas_token = file_sas_token)
blob_name = '{0}/{1}/{2}'.format(correlation_guid, directory_name, file_name)
blob_service.create_container(container_name)
try:
blob_service.copy_blob(container_name, blob_name, file_url)
except Exception as e:
raise ValueError('Missing file ' + file_name)
blob_sas_token = blob_service.generate_blob_shared_access_signature(
container_name,
blob_name,
permission = BlobPermissions.READ,
expiry = datetime.now() + timedelta(days = 1000))
return blob_service.make_blob_url(container_name, blob_name, sas_token = blob_sas_token)
def post_file(share_name, path_to_file):
try:
account_name, account_key = get_auth(request.authorization)
file_service = FileService(account_name=account_name,
account_key=account_key)
start_timedelta, expiry_timedelta = get_sas_params(request.args)
directory_name, file_name = get_location(path_to_file)
if request.headers.get('Transfer-Encoding') == 'chunked':
file_service.create_file_from_stream(share_name,
directory_name,
file_name,
request.stream,
count=4096)
else:
file_service.create_file_from_bytes(share_name, directory_name,
file_name, request.get_data())
sas_token = file_service.generate_file_shared_access_signature(
share_name,
directory_name=directory_name,
file_name=file_name,
permission=SharePermissions(read=True),
expiry=datetime.now() + expiry_timedelta,
start=start_timedelta,
id=None,
ip=None,
protocol='https',
cache_control=request.headers.get('Cache-Control'),
content_disposition=request.headers.get(
'Content-Disposition: attachment;'),
content_encoding=request.headers.get('Content-Encoding'),
content_language=request.headers.get('Content-Language'),
content_type=request.headers.get('Content-Type'))
url = file_service.make_file_url(share_name,
directory_name,
file_name,
protocol='https',
sas_token=sas_token)
return Response(response=url + "",
status=200,
content_type='text/plain')
except Exception as e:
logger.exception(e)
return abort(500, e)
def generate_url(self, remote_file):
"""Sign a remote file to distribute. The azure url format is https://myaccount.blob.core.windows.net/mycontainer/myblob.
Args:
remote_file(str): The blob that we want to sign.
"""
parse_url = _parse_url(remote_file)
key = self.storage_client.storage_accounts.list_keys(
self.resource_group_name, parse_url.account).keys[0].value
if parse_url.file_type == 'blob':
bs = BlockBlobService(account_name=parse_url.account,
account_key=key)
sas_token = bs.generate_blob_shared_access_signature(
parse_url.container_or_share_name,
parse_url.file,
permission=BlobPermissions.READ,
expiry=datetime.utcnow() + timedelta(hours=24),
)
source_blob_url = bs.make_blob_url(
container_name=parse_url.container_or_share_name,
blob_name=parse_url.file,
sas_token=sas_token)
return source_blob_url
elif parse_url.file_type == 'file':
fs = FileService(account_name=parse_url.account, account_key=key)
sas_token = fs.generate_file_shared_access_signature(
share_name=parse_url.container_or_share_name,
directory_name=parse_url.path,
file_name=parse_url.file,
permission=BlobPermissions.READ,
expiry=datetime.utcnow() + timedelta(hours=24),
)
source_file_url = fs.make_file_url(
share_name=parse_url.container_or_share_name,
directory_name=parse_url.path,
file_name=parse_url.file,
sas_token=sas_token)
return source_file_url
else:
raise ValueError(
"This azure storage type is not valid. It should be blob or file."
)
