def setUp(self):
self.app = proxy_server.Application(None, FakeMemcache(),
account_ring=FakeAccountRing(''),
container_ring=FakeContainerRing(''),
object_ring=FakeObjectRing(''),
logger=FakeLogger())
self.base = Controller(self.app)
def __init__(self, app, version, expose_info, disallowed_sections,
admin_key):
Controller.__init__(self, app)
self.expose_info = expose_info
self.disallowed_sections = disallowed_sections
self.admin_key = admin_key
self.allowed_hmac_methods = {'HEAD': ['HEAD', 'GET'], 'GET': ['GET']}
def test_transfer_headers_with_sysmeta(self):
base = Controller(self.app)
good_hdrs = {'x-base-sysmeta-foo': 'ok',
'X-Base-sysmeta-Bar': 'also ok'}
bad_hdrs = {'x-base-sysmeta-': 'too short'}
hdrs = dict(good_hdrs)
hdrs.update(bad_hdrs)
dst_hdrs = HeaderKeyDict()
base.transfer_headers(hdrs, dst_hdrs)
self.assertEqual(HeaderKeyDict(good_hdrs), dst_hdrs)
def test_generate_request_headers(self):
base = Controller(self.app)
src_headers = {'x-remove-base-meta-owner': 'x',
'x-base-meta-size': '151M',
'new-owner': 'Kun'}
req = Request.blank('/v1/a/c/o', headers=src_headers)
dst_headers = base.generate_request_headers(5.0, 0, req, transfer=True)
expected_headers = {'x-base-meta-owner': '',
'x-base-meta-size': '151M'}
for k, v in expected_headers.iteritems():
self.assertTrue(k in dst_headers)
self.assertEqual(v, dst_headers[k])
self.assertFalse('new-owner' in dst_headers)
def test_account_info(self):
base = Controller(self.app)
info = base.account_info('a')
info = {'status': '201', 'bytes': '2000', 'container_count': '1000'}
with patch('osd.proxyService.controllers.base.get_info', return_value=info):
info = base.account_info('a')
self.assertEquals(info, ([{'ip': '1.2.3.4', 'port': '0000'}], 'fs1', 'a', 1000))
info = {'status': '201', 'bytes': '2000', 'container_count': None}
with patch('osd.proxyService.controllers.base.get_info', return_value=info):
info = base.account_info('a')
self.assertEquals(info, ([{'ip': '1.2.3.4', 'port': '0000'}], 'fs1', 'a', 0))
def test_container_info(self):
base = Controller(self.app)
info = base.container_info('a', 'c')
self.assertEquals(info['filesystem'], None)
self.assertEquals(info['node'], None)
self.assertEquals(info['directory'], None)
info = {'status': '201', 'bytes': '2000', 'total_object_count': '1000'}
with patch('osd.proxyService.controllers.base.get_info', return_value=info):
info = base.container_info('a', 'c')
self.assertEquals(info['filesystem'], 'fs1')
self.assertEquals(info['node'], [{'ip': '1.2.3.4', 'port': '0000'}])
self.assertEquals(info['directory'], 'a1')
def test_generate_request_headers_with_sysmeta(self):
base = Controller(self.app)
good_hdrs = {'x-base-sysmeta-foo': 'ok',
'X-Base-sysmeta-Bar': 'also ok'}
bad_hdrs = {'x-base-sysmeta-': 'too short'}
hdrs = dict(good_hdrs)
hdrs.update(bad_hdrs)
req = Request.blank('/v1/a/c/o', headers=hdrs)
dst_headers = base.generate_request_headers(5.0, 0, req, transfer=True)
for k, v in good_hdrs.iteritems():
self.assertTrue(k.lower() in dst_headers)
self.assertEqual(v, dst_headers[k.lower()])
for k, v in bad_hdrs.iteritems():
self.assertFalse(k.lower() in dst_headers)
def test_delete_component_from_block_req(self):
base = Controller(self.app)
#self.base.block_req_dict = MagicMock({('1.2.3.4', '0000'): True, ('1.2.3.4', '1111'): False})
self.base.add_component_in_block_req('Account', 'X1')
self.base.add_component_in_block_req('Account', 'X2')
self.base.delete_component_from_block_req('Account', 'X1')
self.assertEqual(self.base.block_req_dict, {('Account', 'X2'): True})
def test_GETorHEAD_base(self):
base = Controller(self.app)
req = Request.blank('/v1/a/c/o/with/slashes')
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
resp = base.GETorHEAD_base(req, 'object', FakeObjectRing(''), [{'ip': '1.2.3', 'port': '0000'}], \
'fs0', 'd0', '/a/c/o/with/slashes', 5.0, 0)
self.assertTrue('swift.object/a/c/o/with/slashes' in resp.environ)
self.assertEqual(
resp.environ['swift.object/a/c/o/with/slashes']['status'], 200)
req = Request.blank('/v1/a/c/o')
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
resp = base.GETorHEAD_base(req, 'object', FakeObjectRing(''), [{'ip': '1.2.3', 'port': '0000'}], \
'fs0', 'd0', '/a/c/o', 5.0, 0)
self.assertTrue('swift.object/a/c/o' in resp.environ)
self.assertEqual(resp.environ['swift.object/a/c/o']['status'], 200)
req = Request.blank('/v1/a/c')
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
resp = base.GETorHEAD_base(req, 'container', FakeContainerRing(''), [{'ip': '1.2.3', 'port': '0000'}], \
'fs0', 'd0', '/a/c', 5.0, 0)
self.assertTrue('swift.container/a/c' in resp.environ)
self.assertEqual(resp.environ['swift.container/a/c']['status'], 200)
req = Request.blank('/v1/a')
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
resp = base.GETorHEAD_base(req, 'account', FakeAccountRing(''), [{'ip': '1.2.3', 'port': '0000'}], \
'fs0', 'd0', '/a', 5.0, 0)
self.assertTrue('swift.account/a' in resp.environ)
self.assertEqual(resp.environ['swift.account/a']['status'], 200)
def test_have_quorum(self):
base = Controller(self.app)
# just throw a bunch of test cases at it
self.assertEqual(base.have_quorum([201, 404], 3), False)
self.assertEqual(base.have_quorum([201, 201], 4), False)
self.assertEqual(base.have_quorum([201, 201, 404, 404], 4), False)
self.assertEqual(base.have_quorum([201, 503, 503, 201], 4), False)
self.assertEqual(base.have_quorum([201, 201], 3), True)
self.assertEqual(base.have_quorum([404, 404], 3), True)
self.assertEqual(base.have_quorum([201, 201], 2), True)
self.assertEqual(base.have_quorum([404, 404], 2), True)
self.assertEqual(base.have_quorum([201, 404, 201, 201], 4), True)
def test_is_req_blocked_without_component(self):
base = Controller(self.app)
self.assertFalse(self.base.is_req_blocked('Account', 'X1'))
def test_add_component_in_block_req(self):
base = Controller(self.app)
self.base.add_component_in_block_req('Account', 'X1')
self.assertEqual(self.base.block_req_dict, {('Account', 'X1'): True})
self.base.add_component_in_block_req('Account', 'X2')
self.assertEqual(self.base.block_req_dict, {('Account', 'X1'): True, ('Account', 'X2'): True})
class TestGlobalMethod(unittest.TestCase):
def setUp(self):
self.app = proxy_server.Application(None, FakeMemcache(),
account_ring=FakeAccountRing(''),
container_ring=FakeContainerRing(''),
object_ring=FakeObjectRing(''),
logger=FakeLogger())
self.base = Controller(self.app)
def tearDown(self):
pass
def test_source_key(self):
self.assertEquals(source_key(FakeResponse({'test': 'value'}, {}, 'a', 'c', 'o')), 0.0)
self.assertEquals(source_key(FakeResponse({'x-put-timestamp': '123'}, {}, 'a', 'c', 'o')), 123.0)
self.assertEquals(source_key(FakeResponse({'x-timestamp': '1231.0'}, {}, 'a', 'c', 'o')), 1231.0)
def test_get_account_memcache_key(self):
self.assertEquals(get_account_memcache_key('test'), 'account/test')
self.assertEquals(get_account_memcache_key(''), 'account/')
def test_get_container_memcache_key(self):
self.assertEquals(get_container_memcache_key('test', 'test_cont'), 'container/test/test_cont')
self.assertRaises(ValueError, get_container_memcache_key, '', '')
self.assertEquals(get_container_memcache_key('', 'test_cont'), 'container//test_cont')
def test__prep_headers_to_info(self):
self.assertEquals(_prep_headers_to_info({'X-Container-Meta-Test': 'Value'}, 'container'), ({}, {'test': 'Value'}, {}))
self.assertEquals(_prep_headers_to_info({'X-Timestamp': '123'}, 'container'), ({'x-timestamp': '123'}, {}, {}))
self.assertEquals(_prep_headers_to_info({'X-Timestamp': '123', 'X-Content-Length': 12}, 'object'), \
({'x-timestamp': '123', 'x-content-length': 12}, {}, {}))
self.assertEquals(_prep_headers_to_info({'X-Container-Sysmeta-test': 'value'}, 'container'), \
({}, {}, {'test': 'value'}))
self.assertEquals(_prep_headers_to_info({'X-Container-Sysmeta-test': 'value', 'X-Container-Meta-Test': 'Value', 'X-Content-Length': 12}, \
'container'), ({'x-content-length': 12}, {'test': 'Value'}, {'test': 'value'}))
def test__get_cache_key(self):
self.assertEquals(_get_cache_key('acc', 'cont'), ('container/acc/cont', 'swift.container/acc/cont'))
self.assertEquals(_get_cache_key('acc', None), ('account/acc', 'swift.account/acc'))
def test_get_object_env_key(self):
self.assertEquals(get_object_env_key('a', 'c', 'o'), 'swift.object/a/c/o')
def test__set_info_cache(self):
env = {}
_set_info_cache(self.app, env, 'a', 'c', FakeResponse({'x-container-meta-test': 'value'}, {}, 'a', 'c', None))
env_expected = {'swift.container/a/c': {'status': 201, 'sync_key': None, 'meta': {'test': 'value'}, 'write_acl': None, 'object_count': None, 'sysmeta': {}, 'bytes': None, 'read_acl': None, 'versions': None}}
self.assertEquals(env, env_expected)
env = {}
_set_info_cache(self.app, env, 'a', None, FakeResponse({'x-account-meta-test': 'value'}, {}, 'a', None, None))
env_expected = {'swift.account/a': {'status': 201, 'container_count': None, 'bytes': None, 'total_object_count': None, 'meta': {'test': 'value'}, 'sysmeta': {}}}
self.assertEquals(env, env_expected)
def test__set_object_info_cache(self):
env = {}
_set_object_info_cache(self.app, env, 'a', 'c', 'o', FakeResponse({}, {}, 'a', 'c', 'o'))
env_expected = {'swift.object/a/c/o': {'status': 201, 'length': None, 'etag': None, 'type': None, 'meta': {}}}
self.assertEquals(env, env_expected)
def test__get_info_cache(self):
env = {'swift.account/test_Account': {'just_a_test': 'empty'}}
self.assertEquals(_get_info_cache(self.app, env, 'test_Account', None), {'just_a_test': 'empty'})
env = {'swift.container/a/c': {'just_a_test': 'empty'}}
self.assertEquals(_get_info_cache(self.app, env, 'a', 'c'), {'just_a_test': 'empty'})
self.assertEquals(_get_info_cache(self.app, {}, 'test_Account', None), None)
def test_is_good_source(self):
req = Request.blank('/')
handler = GetOrHeadHandler(None, req, 'Object', None, None, None, None, None,
{'Range': 'bytes=-100'})
self.assertEquals(handler.is_good_source(FakeResponse({}, {}, 'a', 'c', 'o', 416)), True)
handler = GetOrHeadHandler(None, req, 'Container', None, None, None, None, None,
{'Range': 'bytes=-100'})
self.assertEquals(handler.is_good_source(FakeResponse({}, {}, 'a', 'c', 'o', 416)), False)
self.assertEquals(handler.is_good_source(FakeResponse({}, {}, 'a', 'c', 'o', 200)), True)
self.assertEquals(handler.is_good_source(FakeResponse({}, {}, 'a', 'c', 'o', 311)), True)
def test__get_source_and_node(self):
req = Request.blank('/')
handler = GetOrHeadHandler(self.app, req, 'Object', None, [{'ip': '1.2.3', 'port': '0000'}], None, None, None,
{'Range': 'bytes=-100'})
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(side_effect=Exception)):
self.assertEquals(handler._get_source_and_node(), (None, None))
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
self.assertEquals(handler._get_source_and_node()[1], {'ip': '1.2.3', 'port': '0000'})
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(507)):
self.assertEquals(handler._get_source_and_node(), (None, None))
def test_get_working_response(self):
req = Request.blank('/')
handler = GetOrHeadHandler(self.app, req, 'Object', None, [{'ip': '1.2.3', 'port': '0000'}], None, None, None,
{'Range': 'bytes=-100'})
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(side_effect=Exception)):
self.assertEquals(handler.get_working_response(req), None)
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
self.assertTrue(handler.get_working_response(req) is not None)
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(503)):
self.assertEquals(handler.get_working_response(req), None)
def test__x_remove_headers(self):
self.assertEquals(self.base._x_remove_headers(), [])
def test_transfer_headers(self):
dst_headers = {}
src_headers = {'x-remove-base-meta-key': 'value'}
self.base.transfer_headers(src_headers, dst_headers)
self.assertEquals(dst_headers, {'x-base-meta-key': ''})
dst_headers = {}
src_headers = {'x-base-sysmeta-key': 'value'}
self.base.transfer_headers(src_headers, dst_headers)
self.assertEquals(dst_headers, {'x-base-sysmeta-key': 'value'})
def test_account_info(self):
with patch('osd.proxyService.controllers.base.get_info',
return_value={'container_count': 2}):
self.assertEquals(self.base.account_info('a'), ([{'ip': '1.2.3.4', 'port': '0000'}], 'fs1', 'a', 2))
with patch('osd.proxyService.controllers.base.get_info',
return_value={'container_count': None}):
self.assertEquals(self.base.account_info('a'), ([{'ip': '1.2.3.4', 'port': '0000'}], 'fs1', 'a', 0))
self.assertEquals(self.base.account_info('a'), (None, None, None, None))
def test_container_info(self):
with patch('osd.proxyService.controllers.base.get_info',
return_value={'object_count': 2}):
self.assertEquals(self.base.container_info('a', 'c'), {'node': [{'ip': '1.2.3.4', 'port': '0000'}], 'filesystem': 'fs1', \
'directory': 'a1', 'object_count': 2})
with patch('osd.proxyService.controllers.base.get_info',
return_value=None):
self.assertEquals(self.base.container_info('a', 'c'), {'status': 0, 'sync_key': None, 'node': None, 'meta': {}, \
'sysmeta': {}, 'read_acl': None, 'object_count': None, 'write_acl': None, 'bytes': None, 'filesystem': None, 'directory': None, 'versions': None})
def test_make_requests(self):
req = Request.blank('/v1/a/c/o')
with patch('osd.proxyService.controllers.base.'
'http_connect', side_effect=Exception):
resp = self.base.make_requests(req, FakeObjectRing(''), [{'ip': '1.2.3.4', 'port': '0000'}], 'fs1', \
'd1', 'HEAD', '/a/c/o', {'test': 'value'})
self.assertEqual(resp.status, '503 Internal Server Error')
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
resp = self.base.make_requests(req, FakeObjectRing(''), [{'ip': '1.2.3.4', 'port': '0000'}], 'fs1', \
'd1', 'HEAD', '/a/c/o', {'test': 'value'})
self.assertEqual(resp.status.split()[0], '200')
def test_best_response(self):
req = Request.blank('/v1/a/c/o')
resp = self.base.best_response(req, [], [], [], 'object')
self.assertEqual(resp.status, '503 Internal Server Error')
req = Request.blank('/v1/a/c/o')
resp = self.base.best_response(req, [200], ['Fake'], [''], 'object', {})
self.assertEqual(resp.status, '200 Fake')
req = Request.blank('/v1/a/c/o')
resp = self.base.best_response(req, [412], ['Fake'], [''], 'object', {})
self.assertEqual(resp.status, '412 Fake')
req = Request.blank('/v1/a/c/o')
resp = self.base.best_response(req, [500], ['Fake'], [''], 'object', {})
self.assertEqual(resp.status, '503 Internal Server Error')
def test_autocreate_account(self):
with patch('osd.proxyService.controllers.base.'
'http_connect', side_effect=Exception):
clear_info_cache = MagicMock()
self.base.autocreate_account({}, 'a')
self.assertFalse(clear_info_cache.called)
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(503)):
clear_info_cache = MagicMock()
self.base.autocreate_account({}, 'a')
self.assertFalse(clear_info_cache.called)
def test_autocreate_account_success_case(self):
with patch('osd.proxyService.controllers.base.'
'http_connect', fake_http_connect(200)):
clear_info_cache = MagicMock()
self.base.autocreate_account({}, 'a')
#self.assertTrue(clear_info_cache.called)
#clear_info_cache.assert_called_once_with(self.app, {}, 'a')
def test_add_component_in_block_req(self):
base = Controller(self.app)
self.base.add_component_in_block_req('Account', 'X1')
self.assertEqual(self.base.block_req_dict, {('Account', 'X1'): True})
self.base.add_component_in_block_req('Account', 'X2')
self.assertEqual(self.base.block_req_dict, {('Account', 'X1'): True, ('Account', 'X2'): True})
def test_delete_component_from_block_req(self):
base = Controller(self.app)
#self.base.block_req_dict = MagicMock({('1.2.3.4', '0000'): True, ('1.2.3.4', '1111'): False})
self.base.add_component_in_block_req('Account', 'X1')
self.base.add_component_in_block_req('Account', 'X2')
self.base.delete_component_from_block_req('Account', 'X1')
self.assertEqual(self.base.block_req_dict, {('Account', 'X2'): True})
def test_is_req_blocked_without_component(self):
base = Controller(self.app)
self.assertFalse(self.base.is_req_blocked('Account', 'X1'))
def test_is_req_blocked_with_component(self):
self.base.add_component_in_block_req('Account', 'X1')
self.assertTrue(self.base.is_req_blocked('Account', 'X1'))
self.assertFalse(self.base.is_req_blocked('', ''))
self.base.add_component_in_block_req('Account', 'X2')
self.assertTrue(self.base.is_req_blocked('Account', 'X2'))
self.base.add_component_in_block_req('Account', 'X3')
self.assertTrue(self.base.is_req_blocked('Account', 'X3'))
self.assertFalse(self.base.is_req_blocked('Account', 'X5'))
def test_update_map_for_account(self):
pass
def __init__(self, app, account_name, **kwargs):
Controller.__init__(self, app)
self.account_name = unquote(account_name)
if not self.app.allow_account_management:
self.allowed_methods.remove('PUT')
self.allowed_methods.remove('DELETE')
def __init__(self, app, **kwargs):
Controller.__init__(self, app)
self.app.logger.info("STOP_SERVICE constructor")
def __init__(self, app, account_name, container_name, **kwargs):
Controller.__init__(self, app)
self.account_name = unquote(account_name)
self.container_name = unquote(container_name)