checking for memcache incase not setup

swift/common/middleware/ratelimit.py

@@ -205,6 +205,10 @@ class RateLimitMiddleware(object):
         req = Request(env)
         if self.memcache_client is None:
             self.memcache_client = cache_from_env(env)
+        if not self.memcache_client:
+            self.logger.warning(
+                'Warning: Cannot ratelimit without a memcached client')
+            return self.app(env, start_response)
         try:
             version, account, container, obj = split_path(req.path, 1, 4, True)
         except ValueError:

swift/proxy/server.py

@@ -179,7 +179,7 @@ class Controller(object):
         path = '/%s' % account
         cache_key = 'account%s' % path
         # 0 = no responses, 200 = found, 404 = not found, -1 = mixed responses
-        if self.app.memcache.get(cache_key):
+        if self.app.memcache and self.app.memcache.get(cache_key):
             return partition, nodes
         result_code = 0
         attempts_left = self.app.account_ring.replica_count
@@ -214,7 +214,9 @@ class Controller(object):
             cache_timeout = self.app.recheck_account_existence
         else:
             cache_timeout = self.app.recheck_account_existence * 0.1
-        self.app.memcache.set(cache_key, result_code, timeout=cache_timeout)
+        if self.app.memcache:
+            self.app.memcache.set(cache_key, result_code,
+                                  timeout=cache_timeout)
         if result_code == 200:
             return partition, nodes
         return (None, None)
@@ -234,6 +236,8 @@ class Controller(object):
         partition, nodes = self.app.container_ring.get_nodes(
                 account, container)
         path = '/%s/%s' % (account, container)
+        cache_key = None
+        if self.app.memcache:
             cache_key = get_container_memcache_key(account, container)
             cache_value = self.app.memcache.get(cache_key)
             if isinstance(cache_value, dict):
@@ -284,7 +288,9 @@ class Controller(object):
             cache_timeout = self.app.recheck_container_existence
         else:
             cache_timeout = self.app.recheck_container_existence * 0.1
-        self.app.memcache.set(cache_key, {'status': result_code,
+        if cache_key and self.app.memcache:
+            self.app.memcache.set(cache_key,
+                                  {'status': result_code,
                                    'read_acl': read_acl,
                                    'write_acl': write_acl,
                                    'container_size': container_size},
@@ -886,6 +892,7 @@ class ContainerController(Controller):
         resp = self.GETorHEAD_base(req, 'Container', part, nodes,
                 req.path_info, self.app.container_ring.replica_count)
 
+        if self.app.memcache:
             # set the memcache container size for ratelimiting
             cache_key = get_container_memcache_key(self.account_name,
                                                    self.container_name)
@@ -977,6 +984,7 @@ class ContainerController(Controller):
             statuses.append(503)
             reasons.append('')
             bodies.append('')
+        if self.app.memcache:
             cache_key = get_container_memcache_key(self.account_name,
                                                    self.container_name)
             self.app.memcache.delete(cache_key)
@@ -1031,6 +1039,7 @@ class ContainerController(Controller):
             statuses.append(503)
             reasons.append('')
             bodies.append('')
+        if self.app.memcache:
             cache_key = get_container_memcache_key(self.account_name,
                                                    self.container_name)
             self.app.memcache.delete(cache_key)
@@ -1087,6 +1096,7 @@ class ContainerController(Controller):
             statuses.append(503)
             reasons.append('')
             bodies.append('')
+        if self.app.memcache:
             cache_key = get_container_memcache_key(self.account_name,
                                                    self.container_name)
             self.app.memcache.delete(cache_key)
@@ -1169,6 +1179,7 @@ class AccountController(Controller):
             statuses.append(503)
             reasons.append('')
             bodies.append('')
+        if self.app.memcache:
             self.app.memcache.delete('account%s' % req.path_info.rstrip('/'))
         return self.best_response(req, statuses, reasons, bodies,
                                   'Account PUT')
@@ -1216,6 +1227,7 @@ class AccountController(Controller):
             statuses.append(503)
             reasons.append('')
             bodies.append('')
+        if self.app.memcache:
             self.app.memcache.delete('account%s' % req.path_info.rstrip('/'))
         return self.best_response(req, statuses, reasons, bodies,
                                   'Account POST')

test/unit/common/middleware/test_ratelimit.py

@@ -101,6 +101,9 @@ class FakeLogger(object):
     def info(self, msg):
         pass
 
+    def warning(self, msg):
+        pass
+
 
 def start_response(*args):
     pass
@@ -386,6 +389,20 @@ class TestRateLimit(unittest.TestCase):
         resp = rate_mid.__call__(env, a_callable())
         self.assert_('404 Not Found' in resp[0])
 
+    def test_no_memcache(self):
+        current_rate = 13
+        num_calls = 5
+        conf_dict = {'account_ratelimit': current_rate}
+        self.test_ratelimit = ratelimit.filter_factory(conf_dict)(FakeApp())
+        ratelimit.http_connect = mock_http_connect(204)
+        req = Request.blank('/v/a')
+        req.environ['swift.cache'] = None
+        make_app_call = lambda: self.test_ratelimit(req.environ,
+                                                    start_response)
+        self._run(make_app_call, num_calls, current_rate)
+
+
+
 
 if __name__ == '__main__':
     unittest.main()