1

     2

import pypngtile

     3

     4

import os.path

     5

import threading

     6

     7

class Error (Exception):

     8

    pass

     9

    10

class NotFound (KeyError):

    11

    pass

    12

    13

class InvalidImage (Exception):

    14

    pass

    15

    16

class UncachedImage (Exception):

    17

    pass

    18

    19

class PNGTileStore (object):

    20

    """

    21

        Access pypngtile.Image's on a filesystem.

    22

    23

        Intended to be threadsafe for open()

    24

    """

    25

    26

    IMAGE_TYPES = (

    27

        'png',

    28

    )

    29

    30

    def __init__ (self, image_root):

    31

        if not os.path.isdir(image_root) :

    32

            raise Error("Given image_root does not exist: {image_root}".format(image_root=image_root))

    33

    34

        self.image_root = os.path.abspath(image_root)

    35

    36

        # cache opened Images

    37

        self.images = { }

    38

        self.images_lock = threading.Lock()

    39

    40

    def lookup (self, url):

    41

        """

    42

            Lookup image by request path.

    43

    44

            Returns name, path, type. For dirs, type will be None.

    45

    46

            Raises Error, NotFound, InvalidImage

    47

    48

            Threadless.

    49

        """

    50

    51

        if not os.path.isdir(self.image_root):

    52

            raise Error("Server image_root has gone missing")

    53

    54

        # path to image

    55

        name = url.lstrip('/')

    56

    57

        # build absolute path

    58

        path = os.path.abspath(os.path.join(self.image_root, name))

    59

    60

        # ensure the path points inside the data root

    61

        if not path.startswith(self.image_root):

    62

            raise NotFound(name)

    63

    64

        if not os.path.exists(path):

    65

            raise NotFound(name)

    66

    67

        # determine time

    68

        if os.path.isdir(path):

    69

            return name, path, None

    70

        else:

    71

            basename, type = path.rsplit('.', 1)

    72

    73

            if type not in self.IMAGE_TYPES:

    74

                raise InvalidImage(name)

    75

    76

            return name, path, type

    77

    78

    def list (self, url):

    79

        """

    80

            Yield a series of valid sub-names for the given directory:

    81

                foo.type

    82

                foo/

    83

    84

            The yielded items should be sorted before use.

    85

        """

    86

    87

        name, root, type = self.lookup(url)

    88

    89

        if type:

    90

            raise InvalidImage(name)

    91

    92

        for name in os.listdir(root):

    93

            path = os.path.join(root, name)

    94

    95

            # skip dotfiles

    96

            if name.startswith('.'):

    97

                continue

    98

    99

            # show dirs

   100

            if os.path.isdir(path):

   101

                if not os.access(path, os.R_OK):

   102

                    # skip inaccessible dirs

   103

                    continue

   104

   106

   107

            # examine ext

   108

            if '.' in name:

   109

                name_base, name_type = name.rsplit('.', 1)

   110

            else:

   111

                name_base = name

   112

                name_type = None

   113

   114

            # show .png files with a .cache file

   115

            if name_type in self.IMAGE_TYPES and os.path.exists(os.path.join(root, name_base + '.cache')):

   117

   118

    def open (self, url):

   119

        """

   120

            Return Image object for given URL.

   121

   122

            Raises UncachedImage, pypngtile.Error

   123

   124

            Threadsafe.

   125

        """

   126

   127

        name, path, type = self.lookup(url)

   128

   129

        if not type:

   130

            raise InvalidImage(name)

   131

   132

        # get Image object

   133

        with self.images_lock:

   134

            image = self.images.get(path)

   135

   136

        if not image:

   137

            # open

   138

            image = pypngtile.Image(path)

   139

   140

            # check

   141

            if image.status() not in (pypngtile.CACHE_FRESH, pypngtile.CACHE_STALE):

   142

                raise UncachedImage(name)

   143

   144

            # load

   145

            image.open()

   146

   147

            # cache

   148

            with self.images_lock:

   149

                # we don't really care if some other thread raced us on the same Image and opened it up concurrently...

   150

                # this is just a cache

   151

                self.images[path] = image

   152

   153

        return image, name