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_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