Rebase to stable/kilo

This change ports most of swiftonfile object server fixes and changes
into gluster-swift. Storage policy as a feature is not usable here
(it doesn't make sense).

The hacky way of creating zero byte tracker objects for object
expiration has not been ported to this release due to scalability
issues and the need to have a separate volume.

Change-Id: I17ba27dacea9ac000bdb8934700996e4d17f4251
Signed-off-by: Prashanth Pai <ppai@redhat.com>
Reviewed-on: http://review.gluster.org/13269
Reviewed-by: Thiago da Silva <thiago@redhat.com>
Tested-by: Thiago da Silva <thiago@redhat.com>

1 files changed, 91 insertions, 2 deletions

diff --git a/test/unit/proxy/controllers/test_container.py b/test/unit/proxy/controllers/test_container.py
index 7c8ecf7..715cd94 100644
--- a/test/unit/proxy/controllers/test_container.py
+++ b/test/unit/proxy/controllers/test_container.py
@@ -16,19 +16,61 @@
 import mock
 import unittest
 
+from eventlet import Timeout
+
 from swift.common.swob import Request
 from swift.proxy import server as proxy_server
 from swift.proxy.controllers.base import headers_to_container_info
 from test.unit import fake_http_connect, FakeRing, FakeMemcache
+from swift.common.storage_policy import StoragePolicy
 from swift.common.request_helpers import get_sys_meta_prefix
+from swift.common import utils
+
+from test.unit import patch_policies, mocked_http_conn, debug_logger
+from test.unit.proxy.test_server import node_error_count
 
 
+@patch_policies([StoragePolicy(0, 'zero', True, object_ring=FakeRing())])
 class TestContainerController(unittest.TestCase):
     def setUp(self):
+        # SOF
+        self._orig_hash_suffix = utils.HASH_PATH_SUFFIX
+        self._orig_hash_prefix = utils.HASH_PATH_PREFIX
+        utils.HASH_PATH_SUFFIX = 'endcap'
+        utils.HASH_PATH_PREFIX = ''
+        self.logger = debug_logger()
+        self.container_ring = FakeRing(max_more_nodes=9)
         self.app = proxy_server.Application(None, FakeMemcache(),
+                                            logger=self.logger,
                                             account_ring=FakeRing(),
-                                            container_ring=FakeRing(),
-                                            object_ring=FakeRing())
+                                            container_ring=self.container_ring)
+
+        self.account_info = {
+            'status': 200,
+            'container_count': '10',
+            'total_object_count': '100',
+            'bytes': '1000',
+            'meta': {},
+            'sysmeta': {},
+        }
+
+        class FakeAccountInfoContainerController(
+                proxy_server.ContainerController):
+
+            def account_info(controller, *args, **kwargs):
+                patch_path = 'swift.proxy.controllers.base.get_info'
+                with mock.patch(patch_path) as mock_get_info:
+                    mock_get_info.return_value = dict(self.account_info)
+                    return super(FakeAccountInfoContainerController,
+                                 controller).account_info(
+                                     *args, **kwargs)
+        _orig_get_controller = self.app.get_controller
+
+        def wrapped_get_controller(*args, **kwargs):
+            with mock.patch('swift.proxy.server.ContainerController',
+                            new=FakeAccountInfoContainerController):
+                return _orig_get_controller(*args, **kwargs)
+        self.app.get_controller = wrapped_get_controller
 
     def test_container_info_in_response_env(self):
         controller = proxy_server.ContainerController(self.app, 'a', 'c')
@@ -118,6 +160,53 @@ class TestContainerController(unittest.TestCase):
         self.assertEqual(context['headers'][user_meta_key], 'bar')
         self.assertNotEqual(context['headers']['x-timestamp'], '1.0')
 
+    def test_node_errors(self):
+        self.app.sort_nodes = lambda n: n
+
+        for method in ('PUT', 'DELETE', 'POST'):
+            def test_status_map(statuses, expected):
+                self.app._error_limiting = {}
+                req = Request.blank('/v1/a/c', method=method)
+                with mocked_http_conn(*statuses) as fake_conn:
+                    print 'a' * 50
+                    resp = req.get_response(self.app)
+                self.assertEqual(resp.status_int, expected)
+                for req in fake_conn.requests:
+                    self.assertEqual(req['method'], method)
+                    self.assert_(req['path'].endswith('/a/c'))
+
+            base_status = [201] * 3
+            # test happy path
+            test_status_map(list(base_status), 201)
+            for i in range(3):
+                self.assertEqual(node_error_count(
+                    self.app, self.container_ring.devs[i]), 0)
+            # single node errors and test isolation
+            for i in range(3):
+                status_list = list(base_status)
+                status_list[i] = 503
+                status_list.append(201)
+                test_status_map(status_list, 201)
+                for j in range(3):
+                    expected = 1 if j == i else 0
+                    self.assertEqual(node_error_count(
+                        self.app, self.container_ring.devs[j]), expected)
+            # timeout
+            test_status_map((201, Timeout(), 201, 201), 201)
+            self.assertEqual(node_error_count(
+                self.app, self.container_ring.devs[1]), 1)
+
+            # exception
+            test_status_map((Exception('kaboom!'), 201, 201, 201), 201)
+            self.assertEqual(node_error_count(
+                self.app, self.container_ring.devs[0]), 1)
+
+            # insufficient storage
+            test_status_map((201, 201, 507, 201), 201)
+            self.assertEqual(node_error_count(
+                self.app, self.container_ring.devs[2]),
+                self.app.error_suppression_limit + 1)
+
 
 if __name__ == '__main__':
     unittest.main()