Statistics
| Branch: | Tag: | Revision:

root / pithos / backends / lib / sqlalchemy / xfeatures.py @ 7759260d

History | View | Annotate | Download (7.9 kB)

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 collections import defaultdict
35
from sqlalchemy import Table, Column, String, Integer, MetaData, ForeignKey
36
from sqlalchemy.sql import select, and_
37
from sqlalchemy.schema import Index
38
from sqlalchemy.sql.expression import desc
39

    
40
from dbworker import DBWorker
41

    
42

    
43
class XFeatures(DBWorker):
44
    """XFeatures are path properties that allow non-nested
45
       inheritance patterns. Currently used for storing permissions.
46
    """
47
    
48
    def __init__(self, **params):
49
        DBWorker.__init__(self, **params)
50
        metadata = MetaData()
51
        columns=[]
52
        columns.append(Column('feature_id', Integer, primary_key=True))
53
        columns.append(Column('path', String(2048)))
54
        self.xfeatures = Table('xfeatures', metadata, *columns, mysql_engine='InnoDB')
55
        # place an index on path
56
        Index('idx_features_path', self.xfeatures.c.path)
57
        
58
        columns=[]
59
        columns.append(Column('feature_id', Integer,
60
                              ForeignKey('xfeatures.feature_id',
61
                                         ondelete='CASCADE'),
62
                              primary_key=True))
63
        columns.append(Column('key', Integer, primary_key=True,
64
                              autoincrement=False))
65
        columns.append(Column('value', String(255), primary_key=True))
66
        self.xfeaturevals = Table('xfeaturevals', metadata, *columns, mysql_engine='InnoDB')
67
        
68
        metadata.create_all(self.engine)
69
    
70
    def xfeature_inherit(self, path):
71
        """Return the (path, feature) inherited by the path, or None."""
72
        
73
        s = select([self.xfeatures.c.path, self.xfeatures.c.feature_id])
74
        s = s.where(self.xfeatures.c.path <= path)
75
        s = s.order_by(desc(self.xfeatures.c.path)).limit(1)
76
        r = self.conn.execute(s)
77
        row = r.fetchone()
78
        r.close()
79
        if row and path.startswith(row[0]):
80
            return row
81
        else:
82
            return None
83
    
84
    def xfeature_list(self, path):
85
        """Return the list of the (prefix, feature) pairs matching path.
86
           A prefix matches path if either the prefix includes the path,
87
           or the path includes the prefix.
88
        """
89
        
90
        inherited = self.xfeature_inherit(path)
91
        if inherited:
92
            return [inherited]
93
        
94
        s = select([self.xfeatures.c.path, self.xfeatures.c.feature_id])
95
        s = s.where(and_(self.xfeatures.c.path.like(self.escape_like(path) + '%', escape='\\'),
96
                     self.xfeatures.c.path != path))
97
        s = s.order_by(self.xfeatures.c.path)
98
        r = self.conn.execute(s)
99
        l = r.fetchall()
100
        r.close()
101
        return l
102
    
103
    def xfeature_create(self, path):
104
        """Create and return a feature for path.
105
           If the path already inherits a feature or
106
           bestows to paths already inheriting a feature,
107
           create no feature and return None.
108
           If the path has a feature, return it.
109
        """
110
        
111
        prefixes = self.xfeature_list(path)
112
        pl = len(prefixes)
113
        if (pl > 1) or (pl == 1 and prefixes[0][0] != path):
114
            return None
115
        if pl == 1 and prefixes[0][0] == path:
116
            return prefixes[0][1]
117
        s = self.xfeatures.insert()
118
        r = self.conn.execute(s, path=path)
119
        inserted_primary_key = r.inserted_primary_key[0]
120
        r.close()
121
        return inserted_primary_key
122
    
123
    def xfeature_destroy(self, path):
124
        """Destroy a feature and all its key, value pairs."""
125
        
126
        s = self.xfeatures.delete().where(self.xfeatures.c.path == path)
127
        r = self.conn.execute(s)
128
        r.close()
129
    
130
    def feature_dict(self, feature):
131
        """Return a dict mapping keys to list of values for feature."""
132
        
133
        s = select([self.xfeaturevals.c.key, self.xfeaturevals.c.value])
134
        s = s.where(self.xfeaturevals.c.feature_id == feature)
135
        r = self.conn.execute(s)
136
        d = defaultdict(list)
137
        for key, value in r.fetchall():
138
            d[key].append(value)
139
        r.close()
140
        return d
141
    
142
    def feature_set(self, feature, key, value):
143
        """Associate a key, value pair with a feature."""
144
        
145
        s = self.xfeaturevals.select()
146
        s = s.where(self.xfeaturevals.c.feature_id == feature)
147
        s = s.where(self.xfeaturevals.c.key == key)
148
        s = s.where(self.xfeaturevals.c.value == value)
149
        r = self.conn.execute(s)
150
        xfeaturevals = r.fetchall()
151
        r.close()
152
        if len(xfeaturevals) == 0:
153
            s = self.xfeaturevals.insert()
154
            r = self.conn.execute(s, feature_id=feature, key=key, value=value)
155
            r.close()
156
    
157
    def feature_setmany(self, feature, key, values):
158
        """Associate the given key, and values with a feature."""
159
        
160
        #TODO: more efficient way to do it
161
        for v in values:
162
            self.feature_set(feature, key, v)
163
    
164
    def feature_unset(self, feature, key, value):
165
        """Disassociate a key, value pair from a feature."""
166
        
167
        s = self.xfeaturevals.delete()
168
        s = s.where(and_(self.xfeaturevals.c.feature_id == feature,
169
                     self.xfeaturevals.c.key == key,
170
                     self.xfeaturevals.c.value == value))
171
        r = self.conn.execute(s)
172
        r.close()
173
    
174
    def feature_unsetmany(self, feature, key, values):
175
        """Disassociate the key for the values given, from a feature."""
176
        
177
        for v in values:
178
            conditional = and_(self.xfeaturevals.c.feature_id == feature,
179
                               self.xfeaturevals.c.key == key,
180
                               self.xfeaturevals.c.value == v)
181
            s = self.xfeaturevals.delete().where(conditional)
182
            r = self.conn.execute(s)
183
            r.close()
184
        
185
    def feature_get(self, feature, key):
186
        """Return the list of values for a key of a feature."""
187
        
188
        s = select([self.xfeaturevals.c.value])
189
        s = s.where(and_(self.xfeaturevals.c.feature_id == feature,
190
                     self.xfeaturevals.c.key == key))
191
        r = self.conn.execute(s)
192
        l = [row[0] for row in r.fetchall()]
193
        r.close()
194
        return l
195
    
196
    def feature_clear(self, feature, key):
197
        """Delete all key, value pairs for a key of a feature."""
198
        
199
        s = self.xfeaturevals.delete()
200
        s = s.where(and_(self.xfeaturevals.c.feature_id == feature,
201
                     self.xfeaturevals.c.key == key))
202
        r = self.conn.execute(s)
203
        r.close()