← Back to branch summary

~ubuntu-branches/ubuntu/wily/heat/wily-proposed

« back to all changes in this revision

Viewing changes to contrib/heat_keystone/heat_keystone/resources/group.py

  • Committer: Package Import Robot
  • Author(s): James Page, Corey Bryant, James Page
  • Date: 2015-03-30 11:11:18 UTC
  • mfrom: (1.1.23)
  • Revision ID: package-import@ubuntu.com-20150330111118-2qpycylx6swu4yhj
Tags: 2015.1~b3-0ubuntu1
[ Corey Bryant ]
* New upstream milestone release for OpenStack kilo:
  - d/control: Align with upstream dependencies.
  - d/p/sudoers_patch.patch: Rebased.
  - d/p/fix-requirements.patch: Rebased.

[ James Page ]
* d/p/fixup-assert-regex.patch: Tweak test to use assertRegexpMatches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/heat_keystone/heat_keystone/resources/group.py
 
1
#
 
2
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
 
3
#    not use this file except in compliance with the License. You may obtain
 
4
#    a copy of the License at
 
5
#
 
6
#         http://www.apache.org/licenses/LICENSE-2.0
 
7
#
 
8
#    Unless required by applicable law or agreed to in writing, software
 
9
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
10
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
11
#    License for the specific language governing permissions and limitations
 
12
#    under the License.
 
13
 
 
14
import role_assignments
 
15
 
 
16
from heat.common.i18n import _
 
17
from heat.engine import constraints
 
18
from heat.engine import properties
 
19
from heat.engine import support
 
20
 
 
21
 
 
22
class KeystoneGroup(role_assignments.KeystoneRoleAssignment):
 
23
    '''
 
24
    Heat Template Resource for Keystone Group.
 
25
 
 
26
    heat_template_version: 2013-05-23
 
27
 
 
28
    description: Sample Keystone Group template
 
29
 
 
30
    parameters:
 
31
      group_name:
 
32
        type: string
 
33
        description: Keystone group name
 
34
      group_description:
 
35
        type: string
 
36
        description: Keystone group description
 
37
      group_domain:
 
38
        type: string
 
39
        description: Keystone group domain name
 
40
      group_role:
 
41
        type: string
 
42
        description: role
 
43
      group_role_domain:
 
44
        type: string
 
45
        description: group role domain
 
46
      group_role_project:
 
47
        type: string
 
48
        description: group role project
 
49
 
 
50
    resources:
 
51
      admin_group:
 
52
        type: OS::Keystone::Group
 
53
        properties:
 
54
          name: {get_param: group_name}
 
55
          domain: {get_param: group_domain}
 
56
          description: {get_param: group_description}
 
57
          roles:
 
58
            - role: {get_param: group_role}
 
59
              domain: {get_param: group_role_domain}
 
60
            - role: {get_param: group_role}
 
61
              project: {get_param: group_role_project}
 
62
    '''
 
63
 
 
64
    support_status = support.SupportStatus(
 
65
        version='2015.1',
 
66
        message=_('Supported versions: keystone v3'))
 
67
 
 
68
    PROPERTIES = (
 
69
        NAME, DOMAIN, DESCRIPTION
 
70
    ) = (
 
71
        'name', 'domain', 'description'
 
72
    )
 
73
 
 
74
    properties_schema = {
 
75
        NAME: properties.Schema(
 
76
            properties.Schema.STRING,
 
77
            _('Name of keystone group.'),
 
78
            update_allowed=True
 
79
        ),
 
80
        DOMAIN: properties.Schema(
 
81
            properties.Schema.STRING,
 
82
            _('Name or id of keystone domain.'),
 
83
            default='default',
 
84
            update_allowed=True,
 
85
            constraints=[constraints.CustomConstraint('keystone.domain')]
 
86
        ),
 
87
        DESCRIPTION: properties.Schema(
 
88
            properties.Schema.STRING,
 
89
            _('Description of keystone group.'),
 
90
            default='',
 
91
            update_allowed=True
 
92
        )
 
93
    }
 
94
 
 
95
    (properties_schema.
 
96
     update(role_assignments.KeystoneRoleAssignment.properties_schema))
 
97
 
 
98
    def _create_group(self,
 
99
                      group_name,
 
100
                      description,
 
101
                      domain):
 
102
        domain = (self.client_plugin('keystone').
 
103
                  get_domain_id(domain))
 
104
 
 
105
        return self.keystone().client.groups.create(
 
106
            name=group_name,
 
107
            domain=domain,
 
108
            description=description)
 
109
 
 
110
    def _delete_group(self, group_id):
 
111
        return self.keystone().client.groups.delete(group_id)
 
112
 
 
113
    def _update_group(self,
 
114
                      group_id,
 
115
                      domain,
 
116
                      new_name=None,
 
117
                      new_description=None):
 
118
        values = dict()
 
119
 
 
120
        if new_name is not None:
 
121
            values['name'] = new_name
 
122
        if new_description is not None:
 
123
            values['description'] = new_description
 
124
 
 
125
        values['group'] = group_id
 
126
        domain = (self.client_plugin('keystone').
 
127
                  get_domain_id(domain))
 
128
        values['domain_id'] = domain
 
129
        return self.keystone().client.groups.update(**values)
 
130
 
 
131
    def handle_create(self):
 
132
        group_name = (self.properties.get(self.NAME) or
 
133
                      self.physical_resource_name())
 
134
        description = self.properties.get(self.DESCRIPTION)
 
135
        domain = self.properties.get(self.DOMAIN)
 
136
 
 
137
        group = self._create_group(
 
138
            group_name=group_name,
 
139
            description=description,
 
140
            domain=domain
 
141
        )
 
142
 
 
143
        self.resource_id_set(group.id)
 
144
 
 
145
        super(KeystoneGroup, self).handle_create(user_id=None,
 
146
                                                 group_id=group.id)
 
147
 
 
148
    def handle_update(self, json_snippet=None, tmpl_diff=None, prop_diff=None):
 
149
        name = prop_diff.get(self.NAME) or self.physical_resource_name()
 
150
        description = prop_diff.get(self.DESCRIPTION)
 
151
        domain = (prop_diff.get(self.DOMAIN) or
 
152
                  self._stored_properties_data.get(self.DOMAIN))
 
153
 
 
154
        self._update_group(
 
155
            group_id=self.resource_id,
 
156
            new_name=name,
 
157
            new_description=description,
 
158
            domain=domain
 
159
        )
 
160
 
 
161
        super(KeystoneGroup, self).handle_update(user_id=None,
 
162
                                                 group_id=self.resource_id,
 
163
                                                 prop_diff=prop_diff)
 
164
 
 
165
    def handle_delete(self):
 
166
        if self.resource_id is not None:
 
167
            try:
 
168
                super(KeystoneGroup, self).handle_delete(
 
169
                    user_id=None,
 
170
                    group_id=self.resource_id)
 
171
 
 
172
                self._delete_group(group_id=self.resource_id)
 
173
            except Exception as ex:
 
174
                self.client_plugin('keystone').ignore_not_found(ex)
 
175
 
 
176
 
 
177
def resource_mapping():
 
178
    return {
 
179
        'OS::Keystone::Group': KeystoneGroup
 
180
    }