def GET(self, req):
     try:
         drive, part, account, container, direr = split_path(
             unquote(req.path), 4, 5, True)
         validate_device_partition(drive, part)
     except ValueError, err:
         return jresponse('-1', 'bad request', req,400)

    def initialize_request(self):
        """
        Basic validation of request and mount check.

        This function will be called before attempting to acquire a
        replication semaphore lock, so contains only quick checks.
        """
        # This environ override has been supported since eventlet 0.14:
        # https://bitbucket.org/eventlet/eventlet/commits/ \
        #     4bd654205a4217970a57a7c4802fed7ff2c8b770
        self.request.environ['eventlet.minimum_write_chunk_size'] = 0
        self.device, self.partition, self.policy = \
            request_helpers.get_name_and_placement(self.request, 2, 2, False)
        self.frag_index = self.node_index = None
        if self.request.headers.get('X-Backend-Ssync-Frag-Index'):
            self.frag_index = int(
                self.request.headers['X-Backend-Ssync-Frag-Index'])
        if self.request.headers.get('X-Backend-Ssync-Node-Index'):
            self.node_index = int(
                self.request.headers['X-Backend-Ssync-Node-Index'])
            if self.node_index != self.frag_index:
                # a primary node should only recieve it's own fragments
                raise swob.HTTPBadRequest(
                    'Frag-Index (%s) != Node-Index (%s)' % (
                        self.frag_index, self.node_index))
        utils.validate_device_partition(self.device, self.partition)
        self.diskfile_mgr = self.app._diskfile_router[self.policy]
        if not self.diskfile_mgr.get_dev_path(self.device):
            raise swob.HTTPInsufficientStorage(drive=self.device)
        self.fp = self.request.environ['wsgi.input']

 def DELETE(self, request):
     """Handle HTTP DELETE requests for the Swift Object Server."""
     try:
         device, partition, account, container, obj = split_path(unquote(request.path), 5, 5, True)
         validate_device_partition(device, partition)
     except ValueError, e:
         return HTTPBadRequest(body=str(e), request=request, content_type="text/plain")

 def POST(self, req):
     """Handle HTTP POST request."""
     try:
         drive, part, account, container = split_path(unquote(req.path), 4)
         validate_device_partition(drive, part)
     except ValueError, err:
         return HTTPBadRequest(body=str(err), content_type="text/plain", request=req)

 def DELETE_RECYCLE(self, req):
     try:
         device, partition, account, src_container, src_obj = split_path(
             unquote(req.path), 4, 5, True)
         validate_device_partition(device, partition)
     except ValueError, err:
         return jresponse('-1', 'bad request', req,400)

 def DELETE_RECYCLE(self, req):
     try:
         drive, part, account, src_container, src_direr = split_path(
             unquote(req.path), 4, 5, True)
         validate_device_partition(drive, part)
     except ValueError, err:
         return jresponse('-1', str(err), req,400)

 def GET(self, req):
     """Handle HTTP GET request."""
     try:
         drive, part, account, container, obj = req.split_path(4, 5, True)
         validate_device_partition(drive, part)
     except ValueError, err:
         return HTTPBadRequest(body=str(err), content_type="text/plain", request=req)

 def PUT(self, req):
     """Handle HTTP PUT request."""
     try:
         drive, part, account, container = req.split_path(3, 4)
         validate_device_partition(drive, part)
     except ValueError, err:
         return HTTPBadRequest(body=str(err), content_type='text/plain',
                               request=req)

 def DELETE(self, req):
     """Handle HTTP DELETE request."""
     try:
         drive, part, account = split_path(unquote(req.path), 3)
         validate_device_partition(drive, part)
     except ValueError, err:
         return HTTPBadRequest(body=str(err), content_type='text/plain',
                               request=req)

 def DELETE(self, req):
     """Handle HTTP DELETE request."""
     
     try:
         drive, part, account = split_path(unquote(req.path), 3)
         validate_device_partition(drive, part)
     except ValueError, err:
         return jresponse('-1', 'bad request',req,400) 

 def HEAD(self, req):
     """Handle HTTP HEAD request."""
     try:
         drive, part, account, container = split_path(unquote(req.path),
                                                      3, 4)
         validate_device_partition(drive, part)
     except ValueError, err:
         return jresponse('-1', 'bad request', req,400)

 def PUT(self, request):
     
     try:
         device, partition, account, src_container, src_link = \
             split_path(unquote(request.path), 5, 5, True)
         validate_device_partition(device, partition)
     except ValueError, err:
         return jresponse('-1', 'bad request', request,400) 

 def GET(self, request):
     """Handle HTTP GET requests for the Swift Object Server."""
     start_time = time.time()
     try:
         device, partition, account, container, obj = split_path(unquote(request.path), 5, 5, True)
         validate_device_partition(device, partition)
     except ValueError, err:
         self.logger.increment("GET.errors")
         return HTTPBadRequest(body=str(err), request=request, content_type="text/plain")

 def POST(self, req):
     """Handle HTTP POST request."""
     
     start_time = time.time()
     try:
         drive, part, account, container = split_path(unquote(req.path), 4)
         validate_device_partition(drive, part)
     except ValueError, err:
         return jresponse('-1', 'bad request', req,400) 

 def DELETE(self, request):
     """Handle HTTP DELETE requests for the Swift Object Server."""
     start_time = time.time()
     try:
         device, partition, account, container, obj = \
             split_path(unquote(request.path), 5, 5, True)
         validate_device_partition(device, partition)
     except ValueError, e:
         return jresponse('-1', 'bad request', request,400)

 def HEAD(self, req):
     """Handle HTTP HEAD request."""
     try:
         drive, part, account, container, obj = split_path(
             unquote(req.path), 4, 5, True)
         validate_device_partition(drive, part)
     except ValueError, err:
         return HTTPBadRequest(body=str(err), content_type='text/plain',
                               request=req)

 def GET(self, request):
     # request is global , can not be modify
     # response can be modify
     start_time = time.time()
     try:
         device, partition, account, container, obj = \
             split_path(unquote(request.path), 5, 5, True)
         validate_device_partition(device, partition)
     except ValueError, err:
         return jresponse('-1', 'bad request', request,400)

 def DELETE(self, req):
     """Handle HTTP DELETE request."""
     start_time = time.time()
     try:
         drive, part, account = split_path(unquote(req.path), 3)
         validate_device_partition(drive, part)
     except ValueError, err:
         self.logger.increment('DELETE.errors')
         return HTTPBadRequest(body=str(err), content_type='text/plain',
                               request=req)

 def HEAD(self, request):
     """Handle HTTP HEAD requests for the Swift Object Server."""
     try:
         device, partition, account, container, obj = split_path(unquote(request.path), 5, 5, True)
         validate_device_partition(device, partition)
     except ValueError, err:
         resp = HTTPBadRequest(request=request)
         resp.content_type = "text/plain"
         resp.body = str(err)
         return resp

 def REPLICATE(self, request):
     """
     Handle REPLICATE requests for the Swift Object Server.  This is used
     by the object replicator to get hashes for directories.
     """
     try:
         device, partition, suffix = split_path(unquote(request.path), 2, 3, True)
         validate_device_partition(device, partition)
     except ValueError, e:
         return HTTPBadRequest(body=str(e), request=request, content_type="text/plain")