def test_check_swift_object_exist_client_exception_404(self,
mock_swift_client):
e = ClientException(self.context.project_id)
e.http_status = 404
mock_swift_client.side_effect = e
self.assertFalse(self.backup.check_swift_object_exist(self.context))
def setUp(self):
super(BackupTasksTest, self).setUp()
self.backup = backup_models.DBBackup()
self.backup.id = 'backup_id'
self.backup.name = 'backup_test',
self.backup.description = 'test desc'
self.backup.location = 'http://xxx/z_CLOUD/12e48.xbstream.gz'
self.backup.instance_id = 'instance id'
self.backup.created = 'yesterday'
self.backup.updated = 'today'
self.backup.size = 2.0
self.backup.state = state.BackupState.NEW
self.container_content = (None,
[{'name': 'first'},
{'name': 'second'},
{'name': 'third'}])
backup_models.Backup.delete = MagicMock(return_value=None)
backup_models.Backup.get_by_id = MagicMock(return_value=self.backup)
backup_models.DBBackup.save = MagicMock(return_value=self.backup)
self.backup.delete = MagicMock(return_value=None)
self.swift_client = MagicMock()
remote.create_swift_client = MagicMock(return_value=self.swift_client)
self.swift_client.head_container = MagicMock(
side_effect=ClientException("foo"))
self.swift_client.head_object = MagicMock(
side_effect=ClientException("foo"))
self.swift_client.get_container = MagicMock(
return_value=self.container_content)
self.swift_client.delete_object = MagicMock(return_value=None)
self.swift_client.delete_container = MagicMock(return_value=None)
def setUp(self):
super(BackupTasksTest, self).setUp()
self.backup = backup_models.DBBackup()
self.backup.id = 'backup_id'
self.backup.name = 'backup_test',
self.backup.description = 'test desc'
self.backup.location = 'http://xxx/z_CLOUD/12e48.xbstream.gz'
self.backup.instance_id = 'instance id'
self.backup.created = 'yesterday'
self.backup.updated = 'today'
self.backup.state = backup_models.BackupState.NEW
self.container_content = (None, [{
'name': 'first'
}, {
'name': 'second'
}, {
'name': 'third'
}])
when(backup_models.Backup).delete(any()).thenReturn(None)
when(backup_models.Backup).get_by_id(self.backup.id).thenReturn(
self.backup)
when(self.backup).delete(any()).thenReturn(None)
self.swift_client = mock()
when(remote).create_swift_client(any()).thenReturn(self.swift_client)
when(self.swift_client).head_container(any()).thenRaise(
ClientException("foo"))
when(self.swift_client).head_object(any(), any()).thenRaise(
ClientException("foo"))
when(self.swift_client).get_container(any()).thenReturn(
self.container_content)
when(self.swift_client).delete_object(any(), any()).thenReturn(None)
when(self.swift_client).delete_container(any()).thenReturn(None)
def test_check_swift_object_exist_client_exception_404(self):
e = ClientException(self.context.tenant)
e.http_status = 404
with patch.object(remote, 'get_endpoint', return_value=None),\
patch.object(remote, 'Connection',
side_effect=e):
self.assertFalse(
self.backup.check_swift_object_exist(self.context))
def test_check_swift_object_exist_client_exception_404(self):
e = ClientException(self.context.tenant)
e.http_status = 404
with patch.object(remote, 'get_endpoint', return_value=None),\
patch.object(remote, 'Connection',
side_effect=e):
self.assertFalse(
self.backup.check_swift_object_exist(self.context))
def test_delete_backup_fail_delete_segment(self):
when(self.swift_client).delete_object(any(), 'second').thenRaise(
ClientException("foo"))
when(self.swift_client).delete_container(any()).thenRaise(
ClientException("foo"))
when(self.swift_client).head_container(any()).thenReturn(None)
taskmanager_models.BackupTasks.delete_backup('dummy context',
self.backup.id)
verify(backup_models.Backup, never).delete(self.backup.id)
self.assertEqual(backup_models.BackupState.FAILED, self.backup.state,
"backup should be in FAILED status")
def setUp(self):
super(BackupTasksTest, self).setUp()
self.backup = backup_models.DBBackup()
self.backup.id = 'backup_id'
self.backup.name = 'backup_test',
self.backup.description = 'test desc'
self.backup.location = 'http://xxx/z_CLOUD/12e48.xbstream.gz'
self.backup.instance_id = 'instance id'
self.backup.created = 'yesterday'
self.backup.updated = 'today'
self.backup.size = 2.0
self.backup.state = state.BackupState.NEW
self.container_content = (None, [{
'name': 'first'
}, {
'name': 'second'
}, {
'name': 'third'
}])
self.bm_backup_patches = patch.multiple(
backup_models.Backup,
delete=MagicMock(return_value=None),
get_by_id=MagicMock(return_value=self.backup))
self.bm_backup_mocks = self.bm_backup_patches.start()
self.addCleanup(self.bm_backup_patches.stop)
self.bm_DBBackup_patch = patch.object(
backup_models.DBBackup, 'save',
MagicMock(return_value=self.backup))
self.bm_DBBackup_mock = self.bm_DBBackup_patch.start()
self.addCleanup(self.bm_DBBackup_patch.stop)
self.backup.delete = MagicMock(return_value=None)
self.swift_client = MagicMock()
self.create_swift_client_patch = patch.object(
remote, 'create_swift_client',
MagicMock(return_value=self.swift_client))
self.create_swift_client_mock = self.create_swift_client_patch.start()
self.addCleanup(self.create_swift_client_patch.stop)
self.swift_client.head_container = MagicMock(
side_effect=ClientException("foo"))
self.swift_client.head_object = MagicMock(
side_effect=ClientException("foo"))
self.swift_client.get_container = MagicMock(
return_value=self.container_content)
self.swift_client.delete_object = MagicMock(return_value=None)
self.swift_client.delete_container = MagicMock(return_value=None)
self.storage_patch = patch.object(storage, 'get_storage_strategy')
self.storage_mock = self.storage_patch.start()
self.addCleanup(self.storage_patch.stop)
self.storage_mock.get_container_name = MagicMock(
return_value='database_backups')
def test_swift_auth_token_client_exception(self):
with patch.object(remote, 'get_endpoint', return_value=None),\
patch.object(remote, 'Connection',
side_effect=ClientException(self.context.tenant)):
self.assertRaises(exception.SwiftAuthError,
models.Backup.verify_swift_auth_token,
self.context)
def test_check_swift_object_exist_client_exception(self):
with patch.object(remote, 'get_endpoint', return_value=None),\
patch.object(remote, 'Connection',
side_effect=ClientException(self.context.tenant)):
self.assertRaises(exception.SwiftAuthError,
self.backup.check_swift_object_exist,
self.context)
def finish_chunk(self):
logging.debug("ChunkObject: finish_chunk")
try:
self.chunkable_http.send("0\r\n\r\n")
response = self.chunkable_http.getresponse()
except (timeout, SSLError, HTTPException), err:
raise ClientException(err.message)
def authenticate(self, username, api_key):
"""Authenticates and opens the connection"""
if not username or not api_key:
raise ClientException("username/password required", http_status=401)
kwargs = dict(authurl=self.authurl, auth_version="1.0")
tenant_name = None
if self.keystone:
if self.keystone['tenant_separator'] in username:
tenant_name, username = username.split(self.keystone['tenant_separator'], 1)
logging.debug("keystone authurl=%r username=%r tenant_name=%r conf=%r" % (self.authurl, username, tenant_name, self.keystone))
ks = self.keystone
kwargs["auth_version"] = "2.0"
kwargs["tenant_name"] = tenant_name
kwargs["os_options"] = dict(service_type=ks['service_type'],
endpoint_type=ks['endpoint_type'],
region_name=ks['region_name'],
)
self.conn = ProxyConnection(self._listdir_cache.memcache,
user=username,
key=api_key,
**kwargs
)
# force authentication
self.conn.url, self.conn.token = self.conn.get_auth()
self.conn.http_conn = None
# now we are authenticated and we have an username
self.username = username
self.tenant_name = tenant_name
def test_swift_auth_token_client_exception(self, mock_swift_client):
mock_swift_client.side_effect = ClientException(
self.context.project_id
)
self.assertRaises(exception.SwiftAuthError,
models.Backup.verify_swift_auth_token,
self.context)
def send_chunk(self, chunk):
logging.debug("ChunkObject: sending %s bytes" % len(chunk))
try:
self.chunkable_http.send("%X\r\n" % len(chunk))
self.chunkable_http.send(chunk)
self.chunkable_http.send("\r\n")
except (timeout, SSLError, HTTPException), err:
raise ClientException(err.message)
def test_check_swift_object_exist_client_exception(self,
mock_swift_client):
mock_swift_client.side_effect = ClientException(
self.context.project_id
)
self.assertRaises(exception.SwiftAuthError,
self.backup.check_swift_object_exist,
self.context)
def test_delete_backup_fail_delete_segment(self):
when(self.swift_client).delete_object(any(), 'second').thenRaise(
ClientException("foo"))
self.assertRaises(TroveError,
taskmanager_models.BackupTasks.delete_backup,
'dummy context', self.backup.id)
verify(backup_models.Backup, never).delete(self.backup.id)
self.assertEqual(backup_models.BackupState.DELETE_FAILED,
self.backup.state,
"backup should be in DELETE_FAILED status")
def test_delete_backup_fail_delete_manifest(self):
filename = self.backup.location[self.backup.location.rfind("/") + 1:]
when(self.swift_client).delete_object(any(), filename).thenRaise(
ClientException("foo"))
when(self.swift_client).head_object(any(), any()).thenReturn(None)
taskmanager_models.BackupTasks.delete_backup('dummy context',
self.backup.id)
verify(backup_models.Backup, never).delete(self.backup.id)
self.assertEqual(backup_models.BackupState.FAILED, self.backup.state,
"backup should be in FAILED status")
def finish_chunk(self):
if self.raw_conn is None:
self._open_connection()
logging.debug("ChunkObject: finish_chunk")
try:
self.raw_conn.send("0\r\n\r\n")
response = self.raw_conn.getresponse()
except (timeout, SSLError, HTTPException), err:
self.raw_conn.close()
raise ClientException(err.message)
def send_chunk(self, chunk):
if self.raw_conn is None:
self._open_connection()
logging.debug("ChunkObject: sending %s bytes" % len(chunk))
try:
self.raw_conn.send("%X\r\n" % len(chunk))
self.raw_conn.send(chunk)
self.raw_conn.send("\r\n")
except (timeout, SSLError, HTTPException), err:
raise ClientException(err.message)
def test_delete_backup_fail_delete_segment(self):
with patch.object(self.swift_client,
'delete_object',
side_effect=ClientException("foo")):
self.assertRaises(TroveError,
taskmanager_models.BackupTasks.delete_backup,
'dummy context', self.backup.id)
self.assertFalse(backup_models.Backup.delete.called)
self.assertEqual(state.BackupState.DELETE_FAILED,
self.backup.state,
"backup should be in DELETE_FAILED status")
def get_auth(self):
if self.temp_url_key == 'exception':
raise ClientException('I failed!')
return 'http://fake/swift', None
def authenticate(self, username, api_key):
"""Authenticates and opens the connection"""
if not username or not api_key:
raise ClientException("username/password required",
http_status=401)
kwargs = dict(authurl=self.authurl, auth_version="1.0", snet=self.snet)
tenant_name = None
if self.keystone:
if self.keystone['tenant_separator'] in username:
tenant_name, username = username.split(
self.keystone['tenant_separator'], 1)
ks = self.keystone
kwargs["auth_version"] = ks['auth_version']
if ks['auth_version'] == "3":
try:
project_name, project_domain_name = tenant_name.split(
self.keystone['domain_separator'], 1)
except ValueError:
project_name = tenant_name
project_domain_name = 'default'
try:
username, user_domain_name = username.split(
self.keystone['domain_separator'], 1)
except ValueError:
user_domain_name = 'default'
logging.debug(
"keystone project_name=%r project_domain_name=%r username=%r user_domain_name=%r"
% (project_name, project_domain_name, username,
user_domain_name))
kwargs["os_options"] = dict(
service_type=ks['service_type'],
endpoint_type=ks['endpoint_type'],
region_name=ks['region_name'],
project_name=project_name,
project_domain_name=project_domain_name,
user_domain_name=user_domain_name,
)
else:
logging.debug(
"keystone authurl=%r username=%r tenant_name=%r conf=%r" %
(self.authurl, username, tenant_name, self.keystone))
kwargs["tenant_name"] = tenant_name
kwargs["os_options"] = dict(
service_type=ks['service_type'],
endpoint_type=ks['endpoint_type'],
region_name=ks['region_name'],
)
self.conn = ProxyConnection(self._listdir_cache.memcache,
user=username,
key=api_key,
insecure=self.insecure,
**kwargs)
# force authentication
self.conn.url, self.conn.token = self.conn.get_auth()
self.conn.close()
# now we are authenticated and we have an username
self.username = username
self.tenant_name = tenant_name
else:
self.already_sent += len(chunk)
logging.debug("ChunkObject: already sent %s bytes" %
self.already_sent)
def finish_chunk(self):
logging.debug("ChunkObject: finish_chunk")
try:
self.raw_conn.send("0\r\n\r\n")
response = self.raw_conn.getresponse()
except (timeout, SSLError, HTTPException), err:
self.raw_conn.close()
raise ClientException(err.message)
try:
response.read()
except (timeout, SSLError):
# this is not relevant, keep going
pass
# we always close the connection
self.raw_conn.close()
self.conn.request_session.close()
if response.status // 100 != 2:
raise ClientException(
response.reason,
http_status=response.status,
http_reason=response.reason,
)
def get_auth(self):
if self.temp_url_key == "exception":
raise ClientException("I failed!")
return "http://fake/swift", None
