def main():
argument_spec = dict(source_uri=dict(required=True),
source_key=dict(required=True),
destination_account=dict(required=True),
destination_key=dict(required=True),
destination_container=dict(required=True),
destination_blob=dict(required=True),
wait=dict(default=False, type='bool'),
timeout=dict(default=1000))
module = AnsibleModule(argument_spec=argument_spec)
if not HAS_DEPS:
module.fail_json(
msg="requests and azure are required for this module ".format(
HAS_DEPS_EXC))
source_account, source_container, source_blob = split_uri(
module.params.get('source_uri'))
source = CloudStorageAccount(account_name=source_account,
account_key=module.params.get('source_key'))
source_service = source.create_block_blob_service()
destination_service = BlockBlobService(
account_name=module.params.get('destination_account'),
account_key=module.params.get('destination_key'))
source_token = source.generate_shared_access_signature(
Services.BLOB, ResourceTypes.OBJECT, AccountPermissions.READ,
datetime.datetime.now() + timedelta(hours=1))
source_sas_url = source_service.make_blob_url(source_container,
source_blob, 'https',
source_token)
destination_service.create_container(
module.params.get('destination_container'), fail_on_exist=False)
status = destination_service.copy_blob(
module.params.get('destination_container'),
module.params.get('destination_blob'), source_sas_url)
if not module.params.get('wait'):
data = dict(changed=True, status='started')
module.exit_json(**data)
else:
copy = destination_service.get_blob_properties(
module.params.get('destination_container'),
module.params.get('destination_blob')).properties.copy
count = 0
while copy.status != 'success':
count = count + 30
if count > module.params.get('timeout'):
module.fail_json(
msg='Timed out waiting for async copy to complete.')
time.sleep(30)
copy = destination_service.get_blob_properties(
module.params.get('destination_container'),
module.params.get('destination_blob')).properties.copy
data = dict(changed=True, status='completed')
module.exit_json(**data)
class StorageAccountTest(StorageTestCase):
def setUp(self):
super(StorageAccountTest, self).setUp()
self.account_name = self.settings.STORAGE_ACCOUNT_NAME
self.account_key = self.settings.STORAGE_ACCOUNT_KEY
self.sas_token = '?sv=2015-04-05&st=2015-04-29T22%3A18%3A26Z&se=2015-04-30T02%3A23%3A26Z&sr=b&sp=rw&sip=168.1.5.60-168.1.5.70&spr=https&sig=Z%2FRHIX5Xcg0Mq2rqI3OlWTjEg2tYkboXr1P9ZUXDtkk%3D'
self.account = CloudStorageAccount(self.account_name, self.account_key)
#--Helpers-----------------------------------------------------------------
def validate_service(self, service, type):
self.assertIsNotNone(service)
self.assertIsInstance(service, type)
self.assertEqual(service.account_name, self.account_name)
self.assertEqual(service.account_key, self.account_key)
#--Test cases --------------------------------------------------------
def test_create_block_blob_service(self):
# Arrange
# Act
service = self.account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_page_blob_service(self):
# Arrange
# Act
service = self.account.create_page_blob_service()
# Assert
self.validate_service(service, PageBlobService)
def test_create_append_blob_service(self):
# Arrange
# Act
service = self.account.create_append_blob_service()
# Assert
self.validate_service(service, AppendBlobService)
def test_create_table_service(self):
# Arrange
# Act
service = self.account.create_table_service()
# Assert
self.validate_service(service, TableService)
def test_create_queue_service(self):
# Arrange
# Act
service = self.account.create_queue_service()
# Assert
self.validate_service(service, QueueService)
def test_create_file_service(self):
# Arrange
# Act
service = self.account.create_file_service()
# Assert
self.validate_service(service, FileService)
def test_create_service_no_key(self):
# Arrange
# Act
bad_account = CloudStorageAccount('', '')
with self.assertRaises(ValueError):
service = bad_account.create_block_blob_service()
# Assert
def test_create_account_sas(self):
# Arrange
# Act
sas_account = CloudStorageAccount(self.account_name, sas_token=self.sas_token)
service = sas_account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, self.account_name)
self.assertIsNone(service.account_key)
self.assertEqual(service.sas_token, self.sas_token)
def test_create_account_sas_and_key(self):
# Arrange
# Act
account = CloudStorageAccount(self.account_name, self.account_key, self.sas_token)
service = account.create_block_blob_service()
# Assert
self.validate_service(service, BlockBlobService)
def test_create_account_emulated(self):
# Arrange
# Act
account = CloudStorageAccount(is_emulated=True)
service = account.create_block_blob_service()
# Assert
self.assertIsNotNone(service)
self.assertEqual(service.account_name, 'devstoreaccount1')
self.assertIsNotNone(service.account_key)
@record
def test_generate_account_sas(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recordingfile(self.test_mode):
return
# Arrange
token = self.account.generate_shared_access_signature(
Services.BLOB,
ResourceTypes.OBJECT,
AccountPermissions.READ,
datetime.utcnow() + timedelta(hours=1),
)
service = self.account.create_block_blob_service()
data = b'shared access signature with read permission on blob'
container_name='container1'
blob_name = 'blob1.txt'
try:
service.create_container(container_name)
service.create_blob_from_bytes(container_name, blob_name, data)
# Act
url = service.make_blob_url(
container_name,
blob_name,
sas_token=token,
)
response = requests.get(url)
# Assert
self.assertTrue(response.ok)
self.assertEqual(data, response.content)
finally:
service.delete_container(container_name)
