← Back to branch summary

~ubuntu-branches/ubuntu/saucy/heat/saucy

« back to all changes in this revision

Viewing changes to heat/engine/resources/user.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Yolanda Robla, Chuck Short
  • Date: 2013-07-22 16:22:29 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130722162229-zzvfu40id94ii0hc
Tags: 2013.2~b2-0ubuntu1
[ Yolanda Robla ]
* debian/tests: added autopkg tests

[ Chuck Short ]
* New upstream release
* debian/control:
  - Add python-pbr to build-depends.
  - Add python-d2to to build-depends.
  - Dropped python-argparse.
  - Add python-six to build-depends.
  - Dropped python-sendfile.
  - Dropped python-nose.
  - Added testrepository.
  - Added python-testtools.
* debian/rules: Run testrepository instead of nosetets.
* debian/patches/removes-lxml-version-limitation-from-pip-requires.patch: Dropped
  no longer needed.
* debian/patches/fix-package-version-detection-when-building-doc.patch: Dropped
  no longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/engine/resources/user.py
14
14
#    under the License.
15
15
 
16
16
from heat.common import exception
 
17
from heat.engine import clients
17
18
from heat.engine import resource
18
19
 
19
20
from heat.openstack.common import log as logging
36
37
                                          }},
37
38
                         'Policies': {'Type': 'List'}}
38
39
 
39
 
    def __init__(self, name, json_snippet, stack):
40
 
        super(User, self).__init__(name, json_snippet, stack)
41
 
 
42
40
    def _validate_policies(self, policies):
43
41
        for policy in (policies or []):
44
42
            # When we support AWS IAM style policies, we will have to accept
83
81
                                                passwd)
84
82
        self.resource_id_set(uid)
85
83
 
86
 
    def handle_update(self, json_snippet):
87
 
        return self.UPDATE_REPLACE
88
 
 
89
84
    def handle_delete(self):
90
85
        if self.resource_id is None:
91
86
            logger.error("Cannot delete User resource before user created!")
92
87
            return
93
 
        self.keystone().delete_stack_user(self.resource_id)
 
88
        try:
 
89
            self.keystone().delete_stack_user(self.resource_id)
 
90
        except clients.hkc.kc.exceptions.NotFound:
 
91
            pass
 
92
 
 
93
    def handle_suspend(self):
 
94
        if self.resource_id is None:
 
95
            logger.error("Cannot suspend User resource before user created!")
 
96
            return
 
97
        self.keystone().disable_stack_user(self.resource_id)
 
98
 
 
99
    def handle_resume(self):
 
100
        if self.resource_id is None:
 
101
            logger.error("Cannot resume User resource before user created!")
 
102
            return
 
103
        self.keystone().enable_stack_user(self.resource_id)
94
104
 
95
105
    def FnGetRefId(self):
96
106
        return unicode(self.physical_resource_name())
97
107
 
98
108
    def FnGetAtt(self, key):
99
 
        #TODO Implement Arn attribute
 
109
        #TODO(asalkeld) Implement Arn attribute
100
110
        raise exception.InvalidTemplateAttribute(
101
 
            resource=self.physical_resource_name(), key=key)
 
111
            resource=self.name, key=key)
102
112
 
103
113
    def access_allowed(self, resource_name):
104
114
        policies = (self.properties['Policies'] or [])
141
151
        return self.stack.resource_by_refid(self.properties['UserName'])
142
152
 
143
153
    def handle_create(self):
144
 
        try:
145
 
            user_id = self._get_user().resource_id
146
 
        except AttributeError:
 
154
        user = self._get_user()
 
155
        if user is None:
147
156
            raise exception.NotFound('could not find user %s' %
148
157
                                     self.properties['UserName'])
149
158
 
150
 
        kp = self.keystone().get_ec2_keypair(user_id)
 
159
        kp = self.keystone().get_ec2_keypair(user.resource_id)
151
160
        if not kp:
152
161
            raise exception.Error("Error creating ec2 keypair for user %s" %
153
 
                                  user_id)
154
 
        else:
155
 
            self.resource_id_set(kp.access)
156
 
            self._secret = kp.secret
 
162
                                  user)
157
163
 
158
 
    def handle_update(self, json_snippet):
159
 
        return self.UPDATE_REPLACE
 
164
        self.resource_id_set(kp.access)
 
165
        self._secret = kp.secret
160
166
 
161
167
    def handle_delete(self):
 
168
        self._secret = None
 
169
        if self.resource_id is None:
 
170
            return
 
171
 
 
172
        user = self._get_user()
 
173
        if user is None:
 
174
            logger.warning('Error deleting %s - user not found' % str(self))
 
175
            return
 
176
        user_id = user.resource_id
 
177
        if user_id:
 
178
            try:
 
179
                self.keystone().delete_ec2_keypair(user_id, self.resource_id)
 
180
            except clients.hkc.kc.exceptions.NotFound:
 
181
                pass
 
182
 
162
183
        self.resource_id_set(None)
163
 
        self._secret = None
164
 
        user_id = self._get_user().resource_id
165
 
        if user_id and self.resource_id:
166
 
            self.keystone().delete_ec2_keypair(user_id, self.resource_id)
167
184
 
168
185
    def _secret_accesskey(self):
169
186
        '''
217
234
    properties_schema = {'AllowedResources': {'Type': 'List',
218
235
                                              'Required': True}}
219
236
 
220
 
    def __init__(self, name, json_snippet, stack):
221
 
        super(AccessPolicy, self).__init__(name, json_snippet, stack)
222
 
 
223
237
    def handle_create(self):
224
238
        resources = self.properties['AllowedResources']
225
239
        # All of the provided resource names must exist in this stack
230
244
                raise exception.ResourceNotFound(resource_name=resource,
231
245
                                                 stack_name=self.stack.name)
232
246
 
233
 
    def handle_update(self, json_snippet):
234
 
        return self.UPDATE_REPLACE
235
 
 
236
247
    def access_allowed(self, resource_name):
237
248
        return resource_name in self.properties['AllowedResources']
238
249