code.grnet.gr Git - pithos/blob - pithos/backends/lib/sqlalchemy/xfeatures.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 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)
  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)
  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(path + '%'),
  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         r = self.conn.execute(s)
 149         xfeaturevals = r.fetchall()
 150         r.close()
 151         if len(xfeaturevals) == 0:
 152             s = self.xfeaturevals.insert()
 153             r = self.conn.execute(s, feature_id=feature, key=key, value=value)
 154             r.close()
 155
 156     def feature_setmany(self, feature, key, values):
 157         """Associate the given key, and values with a feature."""
 158
 159         #TODO: more efficient way to do it
 160         for v in values:
 161             self.feature_set(feature, key, v)
 162
 163     def feature_unset(self, feature, key, value):
 164         """Disassociate a key, value pair from a feature."""
 165
 166         s = self.xfeaturevals.delete()
 167         s = s.where(and_(self.xfeaturevals.c.feature_id == feature,
 168                      self.xfeaturevals.c.key == key,
 169                      self.xfeaturevals.c.value == value))
 170         r = self.conn.execute(s)
 171         r.close()
 172
 173     def feature_unsetmany(self, feature, key, values):
 174         """Disassociate the key for the values given, from a feature."""
 175
 176         for v in values:
 177             conditional = and_(self.xfeaturevals.c.feature_id == feature,
 178                                self.xfeaturevals.c.key == key,
 179                                self.xfeaturevals.c.value == v)
 180             s = self.xfeaturevals.delete().where(conditional)
 181             r = self.conn.execute(s)
 182             r.close()
 183
 184     def feature_get(self, feature, key):
 185         """Return the list of values for a key of a feature."""
 186
 187         s = select([self.xfeaturevals.c.value])
 188         s = s.where(and_(self.xfeaturevals.c.feature_id == feature,
 189                      self.xfeaturevals.c.key == key))
 190         r = self.conn.execute(s)
 191         l = [row[0] for row in r.fetchall()]
 192         r.close()
 193         return l
 194
 195     def feature_clear(self, feature, key):
 196         """Delete all key, value pairs for a key of a feature."""
 197
 198         s = self.xfeaturevals.delete()
 199         s = s.where(and_(self.xfeaturevals.c.feature_id == feature,
 200                      self.xfeaturevals.c.key == key))
 201         r = self.conn.execute(s)
 202         r.close()