1

# DeGAL - A pretty simple web image gallery

     2

# Copyright (C) 2007 Tero Marttila

     3

# http://marttila.de/~terom/degal/

     4

#

     5

# This program is free software; you can redistribute it and/or modify

     6

# it under the terms of the GNU General Public License as published by

     7

# the Free Software Foundation; either version 2 of the License, or

     8

# (at your option) any later version.

     9

#

    10

# This program is distributed in the hope that it will be useful,

    11

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    12

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13

# GNU General Public License for more details.

    14

#

    15

# You should have received a copy of the GNU General Public License

    16

# along with this program; if not, write to the

    17

# Free Software Foundation, Inc.,

    18

# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    19

#

    20

    21

import struct

    22

import base64

    23

import shelve

    24

import os.path

    25

    26

from log import index

    27

    30

def int2key (id) :

    31

    """

    32

        Turn an integer into a short-as-possible url-safe string

    33

    """

    34

    for type in ('B', 'H', 'I') :

    35

        try :

    36

            return base64.b64encode(struct.pack(type, id), '-_').rstrip('=')

    37

        except struct.error :

    38

            continue

    39

    40

    raise Exception("ID overflow: %s" % id)

    41

    54

def updateDB (root) :

    55

    """

    56

        DeGAL <= 0.2 used a simple key => path mapping, but now we use

    57

        something more structured, key => (type, dirpath, fname), where

    58

    59

        type    - one of 'img', 'dir'

    60

        dirpath - the path to the directory, e.g. '.', './foobar', './foobar/quux'

    61

        fname   - the filename, one of '', 'DSC9839.JPG', 'this.png', etc.

    62

    """

    63

    64

    db = shelve.open('shorturls2', 'c', writeback=True)

    65

    66

    id = db.get('_id', 1)

    67

    68

    dirqueue = [root]

    69

    70

    # dict of path -> obj

    71

    paths = {}

    72

    73

    index.info("Processing ShortURLs...")

    74

    75

    while dirqueue :

    76

        dir = dirqueue.pop(0)

    77

    78

        dirqueue.extend(dir.subdirs.itervalues())

    79

    80

        if dir.alive :

    81

            paths[dir.path] = dir

    82

    83

        for img in dir.images.itervalues() :

    84

            paths[img.path] = img

    85

    86

    for key in db.keys() :

    87

        if key.startswith('_') :

    88

            continue

    89

    90

        type, dirpath, fname = db[key]

    91

    92

        path = os.path.join(dirpath, fname).rstrip(os.sep)

    93

    94

        try :

    95

            paths.pop(path).shorturl_code = key

    96

            index.debug("Code for `%s' is %s", path, key)

    97

    98

        except KeyError :

    99

            index.debug("Path `%s' in DB does not exist?", path)

   100

   101

    for obj in paths.itervalues() :

   102

        key = int2key(id)

   103

        id += 1

   104

   105

        index.info("Alloc code `%s' for `%s'", key, obj.html_path)

   106

   107

        obj.shorturl_code = key

   108

   109

        db[key] = obj.getObjInfo()

   110

   111

    db['_id'] = id

   112

    db.close()

   113

   114

class DB (object) :

   115

    def __init__ (self, read_only=True) :

   116

        self.db = shelve.open('shorturls2', read_only and 'r' or 'c')

   117

   118

    def html_path (self, key, index) :

   119

        type, dirpath, fname = self.db[key]

   120

   121

        if type == 'img' :

   122

            fname += '.html'

   123

        elif type == 'dir' :

   124

            fname = ''

   125

   126

        if index :

   127

            dirpath = '../%s' % dirpath

   128

   129

            if type == 'dir' and index > 1 : 

   130

                fname = 'index_%s.html' % (index - 1)

   131

   132

        return os.path.join(dirpath, fname)

   133

   134

    def image_info (self, key) :

   135

        type, dirpath, fname = self.db[key]

   136

   137

        if type != 'img' :

   138

            raise ValueError("%s is not an img" % key)

   139

   140

        return dirpath, fname

   141

   142

    def shorturls_for (self, paths) :

   143

        ret = []

   144

   145

        for key in self.db.keys() :

   146

            if key.startswith('_') :

   147

                continue

   148

   149

            type, dir, fname = self.db[key]

   150

            path = os.path.join(dir.lstrip('.').lstrip('/'), fname) 

   151

            if path in paths :

   152

                ret.append(key)

   153

                paths.remove(path)

   154

   155

        if paths :

   156

            raise ValueError("Paths not found: %s" % " ".join(paths))

   157

   158

        return ret

   159