← Back to branch summary

~gandelman-a/ubuntu/precise/keystone/UCA_2012.2.1

« back to all changes in this revision

Viewing changes to keystone/token/backends/sql.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Adam Gandelman, Soren Hansen, Logan Rosen, Chuck Short
  • Date: 2012-09-07 13:04:01 UTC
  • mfrom: (1.1.22)
  • Revision ID: package-import@ubuntu.com-20120907130401-o49wh9xxkr2cmuqx
Tags: 2012.2~rc1~20120906.2517-0ubuntu2
https://launchpad.net/bugs/998991
[ Adam Gandelman ]
* Refreshed patches.

[ Soren Hansen ]
* Update debian/watch to account for symbolically named tarballs and
  use newer URL.
* Fix Launchpad URLs in debian/watch.

[ Logan Rosen ]
* Fix control file to suggest python-memcache instead of python-memcached
  (LP: #998991).

[ Chuck Short ]
* New upstream version.
* Dont FTBFS if the testsuite fails.

Show diffs side-by-side

added added

removed removed

Lines of Context:
keystone/token/backends/sql.py
27
27
 
28
28
class TokenModel(sql.ModelBase, sql.DictBase):
29
29
    __tablename__ = 'token'
30
 
    id_hash = sql.Column(sql.String(64), primary_key=True)
31
 
    id = sql.Column(sql.String(1024))
 
30
    id = sql.Column(sql.String(64), primary_key=True)
32
31
    expires = sql.Column(sql.DateTime(), default=None)
33
32
    extra = sql.Column(sql.JsonBlob())
 
33
    valid = sql.Column(sql.Boolean(), default=True)
34
34
 
35
35
    @classmethod
36
36
    def from_dict(cls, token_dict):
37
37
        # shove any non-indexed properties into extra
38
38
        extra = copy.deepcopy(token_dict)
39
39
        data = {}
40
 
        for k in ('id_hash', 'id', 'expires'):
 
40
        for k in ('id', 'expires'):
41
41
            data[k] = extra.pop(k, None)
42
42
        data['extra'] = extra
43
43
        return cls(**data)
44
44
 
45
45
    def to_dict(self):
46
46
        out = copy.deepcopy(self.extra)
47
 
        out['id_hash'] = self.id
48
47
        out['id'] = self.id
49
48
        out['expires'] = self.expires
50
49
        return out
55
54
    def get_token(self, token_id):
56
55
        session = self.get_session()
57
56
        token_ref = session.query(TokenModel)\
58
 
            .filter_by(id_hash=self.token_to_key(token_id)).first()
 
57
            .filter_by(id=self.token_to_key(token_id),
 
58
                       valid=True).first()
59
59
        now = datetime.datetime.utcnow()
60
60
        if token_ref and (not token_ref.expires or now < token_ref.expires):
61
61
            return token_ref.to_dict()
76
76
            data_copy['expires'] = self._get_default_expire_time()
77
77
 
78
78
        token_ref = TokenModel.from_dict(data_copy)
79
 
        token_ref.id_hash = self.token_to_key(token_id)
 
79
        token_ref.id = self.token_to_key(token_id)
 
80
        token_ref.valid = True
80
81
        session = self.get_session()
81
82
        with session.begin():
82
83
            session.add(token_ref)
85
86
 
86
87
    def delete_token(self, token_id):
87
88
        session = self.get_session()
88
 
        token_ref = session.query(TokenModel)\
89
 
                           .filter_by(id_hash=self.token_to_key(token_id))\
90
 
                           .first()
91
 
        if not token_ref:
92
 
            raise exception.TokenNotFound(token_id=token_id)
93
 
 
 
89
        key = self.token_to_key(token_id)
94
90
        with session.begin():
95
 
            if not session.query(TokenModel).filter_by(id=token_id).delete():
 
91
            token_ref = session.query(TokenModel).filter_by(id=key,
 
92
                                                            valid=True).first()
 
93
            if not token_ref:
96
94
                raise exception.TokenNotFound(token_id=token_id)
 
95
            token_ref.valid = False
97
96
            session.flush()
98
97
 
99
98
    def list_tokens(self, user_id):
101
100
        tokens = []
102
101
        now = timeutils.utcnow()
103
102
        for token_ref in session.query(TokenModel)\
104
 
                                .filter(TokenModel.expires > now):
 
103
                                .filter(TokenModel.expires > now)\
 
104
                                .filter_by(valid=True):
105
105
            token_ref_dict = token_ref.to_dict()
106
106
            if 'user' not in token_ref_dict:
107
107
                continue
109
109
                continue
110
110
            tokens.append(token_ref['id'])
111
111
        return tokens
 
112
 
 
113
    def list_revoked_tokens(self):
 
114
        session = self.get_session()
 
115
        tokens = []
 
116
        now = timeutils.utcnow()
 
117
        for token_ref in session.query(TokenModel)\
 
118
                                .filter(TokenModel.expires > now)\
 
119
                                .filter_by(valid=False):
 
120
            token_ref_dict = token_ref.to_dict()
 
121
            record = {
 
122
                'id': token_ref['id'],
 
123
                'expires': token_ref['expires'],
 
124
            }
 
125
            tokens.append(record)
 
126
        return tokens