Python constraints.check_metadata函数代码示例

 def test_check_metadata_size(self):
     headers = {}
     size = 0
     chunk = constraints.MAX_META_NAME_LENGTH + \
         constraints.MAX_META_VALUE_LENGTH
     x = 0
     while size + chunk < constraints.MAX_META_OVERALL_SIZE:
         headers['X-Object-Meta-%04d%s' %
                 (x, 'a' * (constraints.MAX_META_NAME_LENGTH - 4))] = \
             'v' * constraints.MAX_META_VALUE_LENGTH
         size += chunk
         x += 1
     self.assertIsNone(constraints.check_metadata(Request.blank(
         '/', headers=headers), 'object'))
     # add two more headers in case adding just one falls exactly on the
     # limit (eg one header adds 1024 and the limit is 2048)
     headers['X-Object-Meta-%04d%s' %
             (x, 'a' * (constraints.MAX_META_NAME_LENGTH - 4))] = \
         'v' * constraints.MAX_META_VALUE_LENGTH
     headers['X-Object-Meta-%04d%s' %
             (x + 1, 'a' * (constraints.MAX_META_NAME_LENGTH - 4))] = \
         'v' * constraints.MAX_META_VALUE_LENGTH
     resp = constraints.check_metadata(Request.blank(
         '/', headers=headers), 'object')
     self.assertEqual(resp.status_int, HTTP_BAD_REQUEST)
     self.assertIn(b'Total metadata too large', resp.body)

 def test_check_metadata_count(self):
     headers = {}
     for x in range(constraints.MAX_META_COUNT):
         headers["X-Object-Meta-%d" % x] = "v"
     self.assertEquals(constraints.check_metadata(Request.blank("/", headers=headers), "object"), None)
     headers["X-Object-Meta-Too-Many"] = "v"
     self.assertEquals(
         constraints.check_metadata(Request.blank("/", headers=headers), "object").status_int, HTTP_BAD_REQUEST
     )

 def test_check_metadata_count(self):
     headers = {}
     for x in xrange(constraints.MAX_META_COUNT):
         headers['X-Object-Meta-%d' % x] = 'v'
     self.assertEquals(constraints.check_metadata(Request.blank(
         '/', headers=headers), 'object'), None)
     headers['X-Object-Meta-Too-Many'] = 'v'
     self.assertEquals(constraints.check_metadata(Request.blank(
         '/', headers=headers), 'object').status_int, HTTP_BAD_REQUEST)

 def test_validate_bad_meta(self):
     req = Request.blank(
         '/v/a/c/o',
         headers={'x-object-meta-hello':
                  'ab' * constraints.MAX_HEADER_SIZE})
     self.assertEquals(constraints.check_metadata(req, 'object').status_int,
                       HTTP_BAD_REQUEST)
     self.assertIn('x-object-meta-hello', constraints.check_metadata(req,
                   'object').body.lower())

 def test_check_metadata_value_length(self):
     value = 'a' * constraints.MAX_META_VALUE_LENGTH
     headers = {'X-Object-Meta-Name': value}
     self.assertEquals(constraints.check_metadata(Request.blank('/',
         headers=headers), 'object'), None)
     value = 'a' * (constraints.MAX_META_VALUE_LENGTH + 1)
     headers = {'X-Object-Meta-Name': value}
     self.assertEquals(constraints.check_metadata(Request.blank('/',
         headers=headers), 'object').status_int, HTTP_BAD_REQUEST)

 def test_check_metadata_name_length(self):
     name = 'a' * constraints.MAX_META_NAME_LENGTH
     headers = {'X-Object-Meta-%s' % name: 'v'}
     self.assertEquals(constraints.check_metadata(Request.blank('/',
         headers=headers), 'object'), None)
     name = 'a' * (constraints.MAX_META_NAME_LENGTH + 1)
     headers = {'X-Object-Meta-%s' % name: 'v'}
     self.assertEquals(constraints.check_metadata(Request.blank('/',
         headers=headers), 'object').status_int, HTTP_BAD_REQUEST)

 def test_check_metadata_non_utf8(self):
     headers = {'X-Account-Meta-Foo': b'\xff'}
     self.assertEqual(constraints.check_metadata(Request.blank(
         '/', headers=headers), 'account').status_int, HTTP_BAD_REQUEST)
     headers = {b'X-Container-Meta-\xff': 'foo'}
     self.assertEqual(constraints.check_metadata(Request.blank(
         '/', headers=headers), 'container').status_int, HTTP_BAD_REQUEST)
     # Object's OK; its metadata isn't serialized as JSON
     headers = {'X-Object-Meta-Foo': b'\xff'}
     self.assertIsNone(constraints.check_metadata(Request.blank(
         '/', headers=headers), 'object'))

    def test_check_metadata_count(self):
        headers = {}
        for x in range(constraints.MAX_META_COUNT):
            headers['X-Object-Meta-%d' % x] = 'v'
        self.assertIsNone(constraints.check_metadata(Request.blank(
            '/', headers=headers), 'object'))

        headers['X-Object-Meta-Too-Many'] = 'v'
        resp = constraints.check_metadata(Request.blank(
            '/', headers=headers), 'object')
        self.assertEqual(resp.status_int, HTTP_BAD_REQUEST)
        self.assertIn(b'Too many metadata items', resp.body)

 def test_check_metadata_name_length(self):
     name = "a" * constraints.MAX_META_NAME_LENGTH
     headers = {"X-Object-Meta-%s" % name: "v"}
     self.assertEquals(constraints.check_metadata(Request.blank("/", headers=headers), "object"), None)
     name = "a" * (constraints.MAX_META_NAME_LENGTH + 1)
     headers = {"X-Object-Meta-%s" % name: "v"}
     self.assertEquals(
         constraints.check_metadata(Request.blank("/", headers=headers), "object").status_int, HTTP_BAD_REQUEST
     )
     self.assertIn(
         ("X-Object-Meta-%s" % name).lower(),
         constraints.check_metadata(Request.blank("/", headers=headers), "object").body.lower(),
     )

    def test_check_metadata_name_length(self):
        name = 'a' * constraints.MAX_META_NAME_LENGTH
        headers = {'X-Object-Meta-%s' % name: 'v'}
        self.assertIsNone(constraints.check_metadata(Request.blank(
            '/', headers=headers), 'object'))

        name = 'a' * (constraints.MAX_META_NAME_LENGTH + 1)
        headers = {'X-Object-Meta-%s' % name: 'v'}
        resp = constraints.check_metadata(Request.blank(
            '/', headers=headers), 'object')
        self.assertEqual(resp.status_int, HTTP_BAD_REQUEST)
        self.assertIn(
            b'x-object-meta-%s' % name.encode('ascii'), resp.body.lower())
        self.assertIn(b'Metadata name too long', resp.body)

    def test_check_metadata_value_length(self):
        value = 'a' * constraints.MAX_META_VALUE_LENGTH
        headers = {'X-Object-Meta-Name': value}
        self.assertIsNone(constraints.check_metadata(Request.blank(
            '/', headers=headers), 'object'))

        value = 'a' * (constraints.MAX_META_VALUE_LENGTH + 1)
        headers = {'X-Object-Meta-Name': value}
        resp = constraints.check_metadata(Request.blank(
            '/', headers=headers), 'object')
        self.assertEqual(resp.status_int, HTTP_BAD_REQUEST)
        self.assertIn(b'x-object-meta-name', resp.body.lower())
        self.assertIn(
            str(constraints.MAX_META_VALUE_LENGTH).encode('ascii'), resp.body)
        self.assertIn(b'Metadata value longer than 256', resp.body)

 def POST(self, req):
     """HTTP POST request handler."""
     error_response = \
         self.clean_acls(req) or check_metadata(req, 'container')
     if error_response:
         return error_response
     if not req.environ.get('swift_owner'):
         for key in self.app.swift_owner_headers:
             req.headers.pop(key, None)
     if req.environ.get('reseller_request', False) and \
             'X-Container-Sharding' in req.headers:
         req.headers[get_sys_meta_prefix('container') + 'Sharding'] = \
             str(config_true_value(req.headers['X-Container-Sharding']))
     account_partition, accounts, container_count = \
         self.account_info(self.account_name, req)
     if not accounts:
         return HTTPNotFound(request=req)
     container_partition, containers = self.app.container_ring.get_nodes(
         self.account_name, self.container_name)
     headers = self.generate_request_headers(req, transfer=True)
     clear_info_cache(self.app, req.environ,
                      self.account_name, self.container_name)
     resp = self.make_requests(
         req, self.app.container_ring, container_partition, 'POST',
         req.swift_entity_path, [headers] * len(containers))
     return resp

 def PUT(self, req):
     """HTTP PUT request handler."""
     error_response = \
         self.clean_acls(req) or check_metadata(req, 'container')
     if error_response:
         return error_response
     if len(self.container_name) > MAX_CONTAINER_NAME_LENGTH:
         resp = HTTPBadRequest(request=req)
         resp.body = 'Container name length of %d longer than %d' % \
                     (len(self.container_name), MAX_CONTAINER_NAME_LENGTH)
         return resp
     account_partition, accounts, container_count = \
         self.account_info(self.account_name,
                           autocreate=self.app.account_autocreate)
     if self.app.max_containers_per_account > 0 and \
             container_count >= self.app.max_containers_per_account and \
             self.account_name not in self.app.max_containers_whitelist:
         resp = HTTPForbidden(request=req)
         resp.body = 'Reached container limit of %s' % \
                     self.app.max_containers_per_account
         return resp
     if not accounts:
         return HTTPNotFound(request=req)
     container_partition, containers = self.app.container_ring.get_nodes(
         self.account_name, self.container_name)
     headers = self._backend_requests(req, len(containers),
                                      account_partition, accounts)
     if self.app.memcache:
         cache_key = get_container_memcache_key(self.account_name,
                                                self.container_name)
         self.app.memcache.delete(cache_key)
     resp = self.make_requests(
         req, self.app.container_ring,
         container_partition, 'PUT', req.path_info, headers)
     return resp

 def POST(self, req):
     """HTTP POST request handler."""
     error_response = check_metadata(req, 'account')
     if error_response:
         return error_response
     account_partition, accounts = \
         self.app.account_ring.get_nodes(self.account_name)
     headers = self.generate_request_headers(req, transfer=True)
     if self.app.memcache:
         self.app.memcache.delete(
             get_account_memcache_key(self.account_name))
     resp = self.make_requests(
         req, self.app.account_ring, account_partition, 'POST',
         req.path_info, [headers] * len(accounts))
     if resp.status_int == HTTP_NOT_FOUND and self.app.account_autocreate:
         if len(self.account_name) > MAX_ACCOUNT_NAME_LENGTH:
             resp = HTTPBadRequest(request=req)
             resp.body = 'Account name length of %d longer than %d' % \
                         (len(self.account_name), MAX_ACCOUNT_NAME_LENGTH)
             return resp
         resp = self.make_requests(
             Request.blank('/v1/' + self.account_name),
             self.app.account_ring, account_partition, 'PUT',
             '/' + self.account_name, [headers] * len(accounts))
         if not is_success(resp.status_int):
             self.app.logger.warning('Could not autocreate account %r' %
                                     self.account_name)
             return resp
     return resp

    def PUT(self, req):
        """HTTP PUT request handler."""
	print 'in PUT function of accountcontroller class'
        if not self.app.allow_account_management:
            return HTTPMethodNotAllowed(
                request=req,
                headers={'Allow': ', '.join(self.allowed_methods)})
        error_response = check_metadata(req, 'account')
	print 'error_response'
        if error_response:
            return error_response
        if len(self.account_name) > constraints.MAX_ACCOUNT_NAME_LENGTH:
            resp = HTTPBadRequest(request=req)
            resp.body = 'Account name length of %d longer than %d' % \
                        (len(self.account_name),
                         constraints.MAX_ACCOUNT_NAME_LENGTH)
            return resp
        account_partition, accounts = \
            self.app.account_ring.get_nodes(self.account_name)
	print ' account_partition, accounts',account_partion,accounts
        headers = self.generate_request_headers(req, transfer=True)
	print 'headers',headers
        clear_info_cache(self.app, req.environ, self.account_name)
        resp = self.make_requests(
            req, self.app.account_ring, account_partition, 'PUT',
            req.swift_entity_path, [headers] * len(accounts))
	print 'resp',resp
        self.add_acls_from_sys_metadata(resp)
	print 'in PUT function of accountcontroller class END'
        return resp