← 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/project.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/project.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
from heat.common.i18n import _
 
15
from heat.engine import constraints
 
16
from heat.engine import properties
 
17
from heat.engine import resource
 
18
from heat.engine import support
 
19
 
 
20
 
 
21
class KeystoneProject(resource.Resource):
 
22
    '''
 
23
    Heat Template Resource for Keystone Project.
 
24
 
 
25
    heat_template_version: 2013-05-23
 
26
 
 
27
    description: Sample Keystone Project template
 
28
 
 
29
    parameters:
 
30
      project_name:
 
31
        type: string
 
32
        description: Keystone project name
 
33
      project_description:
 
34
        type: string
 
35
        description: Keystone project description
 
36
      project_enabled:
 
37
        type: boolean
 
38
        description: Keystone project is enabled or disabled
 
39
      project_domain:
 
40
        type: string
 
41
        description: Keystone project domain name or id
 
42
 
 
43
    resources:
 
44
      admin_project:
 
45
        type: OS::Keystone::Project
 
46
        properties:
 
47
          name: {get_param: project_name}
 
48
          domain: {get_param: project_domain}
 
49
          description: {get_param: project_description}
 
50
          enabled: {get_param: project_enabled}
 
51
 
 
52
    '''
 
53
 
 
54
    support_status = support.SupportStatus(
 
55
        version='2015.1',
 
56
        message=_('Supported versions: keystone v3'))
 
57
 
 
58
    PROPERTIES = (
 
59
        NAME, DOMAIN, DESCRIPTION, ENABLED
 
60
    ) = (
 
61
        'name', 'domain', 'description', 'enabled'
 
62
    )
 
63
 
 
64
    properties_schema = {
 
65
        NAME: properties.Schema(
 
66
            properties.Schema.STRING,
 
67
            _('Name of keystone project.'),
 
68
            update_allowed=True
 
69
        ),
 
70
        DOMAIN: properties.Schema(
 
71
            properties.Schema.STRING,
 
72
            _('Name or id of keystone domain.'),
 
73
            default='default',
 
74
            update_allowed=True,
 
75
            constraints=[constraints.CustomConstraint('keystone.domain')]
 
76
        ),
 
77
        DESCRIPTION: properties.Schema(
 
78
            properties.Schema.STRING,
 
79
            _('Description of keystone project.'),
 
80
            default='',
 
81
            update_allowed=True
 
82
        ),
 
83
        ENABLED: properties.Schema(
 
84
            properties.Schema.BOOLEAN,
 
85
            _('This project is enabled or disabled.'),
 
86
            default=True,
 
87
            update_allowed=True
 
88
        )
 
89
    }
 
90
 
 
91
    def _create_project(self,
 
92
                        project_name,
 
93
                        description,
 
94
                        domain,
 
95
                        enabled):
 
96
        domain = (self.client_plugin('keystone').
 
97
                  get_domain_id(domain))
 
98
 
 
99
        return self.keystone().client.projects.create(
 
100
            name=project_name,
 
101
            domain=domain,
 
102
            description=description,
 
103
            enabled=enabled)
 
104
 
 
105
    def _delete_project(self, project_id):
 
106
        return self.keystone().client.projects.delete(project_id)
 
107
 
 
108
    def _update_project(self,
 
109
                        project_id,
 
110
                        domain,
 
111
                        new_name=None,
 
112
                        new_description=None,
 
113
                        enabled=None):
 
114
        values = dict()
 
115
 
 
116
        if new_name is not None:
 
117
            values['name'] = new_name
 
118
        if new_description is not None:
 
119
            values['description'] = new_description
 
120
        if enabled is not None:
 
121
            values['enabled'] = enabled
 
122
 
 
123
        values['project'] = project_id
 
124
        domain = (self.client_plugin('keystone').
 
125
                  get_domain_id(domain))
 
126
 
 
127
        values['domain'] = domain
 
128
 
 
129
        return self.keystone().client.projects.update(**values)
 
130
 
 
131
    def handle_create(self):
 
132
        project_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
        enabled = self.properties.get(self.ENABLED)
 
137
 
 
138
        project = self._create_project(
 
139
            project_name=project_name,
 
140
            description=description,
 
141
            domain=domain,
 
142
            enabled=enabled
 
143
        )
 
144
 
 
145
        self.resource_id_set(project.id)
 
146
 
 
147
    def handle_update(self,
 
148
                      json_snippet=None,
 
149
                      tmpl_diff=None,
 
150
                      prop_diff=None):
 
151
        name = prop_diff.get(self.NAME) or self.physical_resource_name()
 
152
        description = prop_diff.get(self.DESCRIPTION)
 
153
        enabled = prop_diff.get(self.ENABLED)
 
154
        domain = (prop_diff.get(self.DOMAIN) or
 
155
                  self._stored_properties_data.get(self.DOMAIN))
 
156
 
 
157
        self._update_project(
 
158
            project_id=self.resource_id,
 
159
            domain=domain,
 
160
            new_name=name,
 
161
            new_description=description,
 
162
            enabled=enabled
 
163
        )
 
164
 
 
165
    def handle_delete(self):
 
166
        if self.resource_id is not None:
 
167
            try:
 
168
                self._delete_project(project_id=self.resource_id)
 
169
            except Exception as ex:
 
170
                self.client_plugin('keystone').ignore_not_found(ex)
 
171
 
 
172
 
 
173
def resource_mapping():
 
174
    return {
 
175
        'OS::Keystone::Project': KeystoneProject
 
176
    }