code.grnet.gr Git - pithos/blob - pithos/backends/lib/hashfiler/blocker.py

   1 # Copyright 2011 GRNET S.A. All rights reserved.
   2 #
   3 # Redistribution and use in source and binary forms, with or
   4 # without modification, are permitted provided that the following
   5 # conditions are met:
   6 #
   7 #   1. Redistributions of source code must retain the above
   8 #      copyright notice, this list of conditions and the following
   9 #      disclaimer.
  10 #
  11 #   2. Redistributions in binary form must reproduce the above
  12 #      copyright notice, this list of conditions and the following
  13 #      disclaimer in the documentation and/or other materials
  14 #      provided with the distribution.
  15 #
  16 # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  17 # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  20 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  23 # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  24 # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  26 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 # POSSIBILITY OF SUCH DAMAGE.
  28 #
  29 # The views and conclusions contained in the software and
  30 # documentation are those of the authors and should not be
  31 # interpreted as representing official policies, either expressed
  32 # or implied, of GRNET S.A.
  33
  34 from os import makedirs
  35 from os.path import isdir, realpath, exists, join
  36 from hashlib import new as newhasher
  37 from binascii import hexlify
  38
  39 from context_file import ContextFile, file_sync_read_chunks
  40
  41
  42 class Blocker(object):
  43     """Blocker.
  44        Required contstructor parameters: blocksize, blockpath, hashtype.
  45     """
  46
  47     blocksize = None
  48     blockpath = None
  49     hashtype = None
  50
  51     def __init__(self, **params):
  52         blocksize = params['blocksize']
  53         blockpath = params['blockpath']
  54         blockpath = realpath(blockpath)
  55         if not isdir(blockpath):
  56             if not exists(blockpath):
  57                 makedirs(blockpath)
  58             else:
  59                 raise ValueError("Variable blockpath '%s' is not a directory" % (blockpath,))
  60
  61         hashtype = params['hashtype']
  62         try:
  63             hasher = newhasher(hashtype)
  64         except ValueError:
  65             msg = "Variable hashtype '%s' is not available from hashlib"
  66             raise ValueError(msg % (hashtype,))
  67
  68         hasher.update("")
  69         emptyhash = hasher.digest()
  70
  71         self.blocksize = blocksize
  72         self.blockpath = blockpath
  73         self.hashtype = hashtype
  74         self.hashlen = len(emptyhash)
  75         self.emptyhash = emptyhash
  76
  77     def _get_rear_block(self, blkhash, create=0):
  78         filename = hexlify(blkhash)
  79         dir = join(self.blockpath, filename[0:2], filename[2:4], filename[4:6])
  80         if not exists(dir):
  81             makedirs(dir)
  82         name = join(dir, filename)
  83         return ContextFile(name, create)
  84
  85     def _check_rear_block(self, blkhash):
  86         filename = hexlify(blkhash)
  87         dir = join(self.blockpath, filename[0:2], filename[2:4], filename[4:6])
  88         name = join(dir, filename)
  89         return exists(name)
  90
  91     def block_hash(self, data):
  92         """Hash a block of data"""
  93         hasher = newhasher(self.hashtype)
  94         hasher.update(data.rstrip('\x00'))
  95         return hasher.digest()
  96
  97     def block_ping(self, hashes):
  98         """Check hashes for existence and
  99            return those missing from block storage.
 100         """
 101         return [h for h in hashes if not self._check_rear_block(h)]
 102
 103     def block_retr(self, hashes):
 104         """Retrieve blocks from storage by their hashes."""
 105         blocksize = self.blocksize
 106         blocks = []
 107         append = blocks.append
 108         block = None
 109
 110         for h in hashes:
 111             with self._get_rear_block(h, 0) as rbl:
 112                 if not rbl:
 113                     break
 114                 for block in rbl.sync_read_chunks(blocksize, 1, 0):
 115                     break # there should be just one block there
 116             if not block:
 117                 break
 118             append(block)
 119
 120         return blocks
 121
 122     def block_stor(self, blocklist):
 123         """Store a bunch of blocks and return (hashes, missing).
 124            Hashes is a list of the hashes of the blocks,
 125            missing is a list of indices in that list indicating
 126            which blocks were missing from the store.
 127         """
 128         block_hash = self.block_hash
 129         hashlist = [block_hash(b) for b in blocklist]
 130         mf = None
 131         missing = [i for i, h in enumerate(hashlist) if not self._check_rear_block(h)]
 132         for i in missing:
 133             with self._get_rear_block(hashlist[i], 1) as rbl:
 134                  rbl.sync_write(blocklist[i]) #XXX: verify?
 135
 136         return hashlist, missing
 137
 138     def block_delta(self, blkhash, offdata=()):
 139         """Construct and store a new block from a given block
 140            and a list of (offset, data) 'patches'. Return:
 141            (the hash of the new block, if the block already existed)
 142         """
 143         if not offdata:
 144             return None, None
 145
 146         blocksize = self.blocksize
 147         block = self.block_retr((blkhash,))
 148         if not block:
 149             return None, None
 150
 151         block = block[0]
 152         newblock = ''
 153         idx = 0
 154         size = 0
 155         trunc = 0
 156         for off, data in offdata:
 157             if not data:
 158                 trunc = 1
 159                 break
 160             newblock += block[idx:off] + data
 161             size += off - idx + len(data)
 162             if size >= blocksize:
 163                 break
 164             off = size
 165
 166         if not trunc:
 167             newblock += block[size:len(block)]
 168
 169         h, a = self.block_stor((newblock,))
 170         return h[0], 1 if a else 0
 171
 172     def block_hash_file(self, openfile):
 173         """Return the list of hashes (hashes map)
 174            for the blocks in a buffered file.
 175            Helper method, does not affect store.
 176         """
 177         hashes = []
 178         append = hashes.append
 179         block_hash = self.block_hash
 180
 181         for block in file_sync_read_chunks(openfile, self.blocksize, 1, 0):
 182             append(block_hash(block))
 183
 184         return hashes
 185
 186     def block_stor_file(self, openfile):
 187         """Read blocks from buffered file object and store them. Return:
 188            (bytes read, list of hashes, list of hashes that were missing)
 189         """
 190         blocksize = self.blocksize
 191         block_stor = self.block_stor
 192         hashlist = []
 193         hextend = hashlist.extend
 194         storedlist = []
 195         sextend = storedlist.extend
 196         lastsize = 0
 197
 198         for block in file_sync_read_chunks(openfile, blocksize, 1, 0):
 199             hl, sl = block_stor((block,))
 200             hextend(hl)
 201             sextend(sl)
 202             lastsize = len(block)
 203
 204         size = (len(hashlist) -1) * blocksize + lastsize if hashlist else 0
 205         return size, hashlist, storedlist
 206