Refactoring of NetworkSettings to extend NetworkConfig
[snaps.git] / snaps / openstack / create_volume.py
1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 #                    and others.  All rights reserved.
3 #
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
7 #
8 #     http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16 import logging
17 import time
18
19 from cinderclient.exceptions import NotFound
20
21 from snaps.config.volume import VolumeConfig
22 from snaps.openstack.openstack_creator import OpenStackVolumeObject
23 from snaps.openstack.utils import cinder_utils
24
25 __author__ = 'spisarski'
26
27 logger = logging.getLogger('create_volume')
28
29 VOLUME_ACTIVE_TIMEOUT = 300
30 VOLUME_DELETE_TIMEOUT = 60
31 POLL_INTERVAL = 3
32 STATUS_ACTIVE = 'available'
33 STATUS_IN_USE = 'in-use'
34 STATUS_FAILED = 'error'
35 STATUS_DELETED = 'deleted'
36
37
38 class OpenStackVolume(OpenStackVolumeObject):
39     """
40     Class responsible for managing an volume in OpenStack
41     """
42
43     def __init__(self, os_creds, volume_settings):
44         """
45         Constructor
46         :param os_creds: The OpenStack connection credentials
47         :param volume_settings: The volume settings
48         :return:
49         """
50         super(self.__class__, self).__init__(os_creds)
51
52         self.volume_settings = volume_settings
53         self.__volume = None
54
55     def initialize(self):
56         """
57         Loads the existing Volume
58         :return: The Volume domain object or None
59         """
60         super(self.__class__, self).initialize()
61
62         self.__volume = cinder_utils.get_volume(
63             self._cinder, volume_settings=self.volume_settings)
64         return self.__volume
65
66     def create(self, block=False):
67         """
68         Creates the volume in OpenStack if it does not already exist and
69         returns the domain Volume object
70         :return: The Volume domain object or None
71         """
72         self.initialize()
73
74         if not self.__volume:
75             self.__volume = cinder_utils.create_volume(
76                 self._cinder, self.volume_settings)
77
78             logger.info(
79                 'Created volume with name - %s', self.volume_settings.name)
80             if self.__volume:
81                 if block:
82                     if self.volume_active(block=True):
83                         logger.info('Volume is now active with name - %s',
84                                     self.volume_settings.name)
85                         return self.__volume
86                     else:
87                         raise VolumeCreationError(
88                             'Volume was not created or activated in the '
89                             'alloted amount of time')
90         else:
91             logger.info('Did not create volume due to cleanup mode')
92
93         return self.__volume
94
95     def clean(self):
96         """
97         Cleanse environment of all artifacts
98         :return: void
99         """
100         if self.__volume:
101             try:
102                 if self.volume_active():
103                     cinder_utils.delete_volume(self._cinder, self.__volume)
104                 else:
105                     logger.warn('Timeout waiting to delete volume %s',
106                                 self.__volume.name)
107             except NotFound:
108                 pass
109
110             try:
111                 if self.volume_deleted(block=True):
112                     logger.info(
113                         'Volume has been properly deleted with name - %s',
114                         self.volume_settings.name)
115                     self.__vm = None
116                 else:
117                     logger.error(
118                         'Volume not deleted within the timeout period of %s '
119                         'seconds', VOLUME_DELETE_TIMEOUT)
120             except Exception as e:
121                 logger.error(
122                     'Unexpected error while checking VM instance status - %s',
123                     e)
124
125         self.__volume = None
126
127     def get_volume(self):
128         """
129         Returns the domain Volume object as it was populated when create() was
130         called
131         :return: the object
132         """
133         return self.__volume
134
135     def volume_active(self, block=False, timeout=VOLUME_ACTIVE_TIMEOUT,
136                       poll_interval=POLL_INTERVAL):
137         """
138         Returns true when the volume status returns the value of
139         expected_status_code
140         :param block: When true, thread will block until active or timeout
141                       value in seconds has been exceeded (False)
142         :param timeout: The timeout value
143         :param poll_interval: The polling interval in seconds
144         :return: T/F
145         """
146         return self._volume_status_check(STATUS_ACTIVE, block, timeout,
147                                          poll_interval)
148
149     def volume_in_use(self):
150         """
151         Returns true when the volume status returns the value of
152         expected_status_code
153         :return: T/F
154         """
155         return self._volume_status_check(STATUS_IN_USE, False, 0, 0)
156
157     def volume_deleted(self, block=False, poll_interval=POLL_INTERVAL):
158         """
159         Returns true when the VM status returns the value of
160         expected_status_code or instance retrieval throws a NotFound exception.
161         :param block: When true, thread will block until active or timeout
162                       value in seconds has been exceeded (False)
163         :param poll_interval: The polling interval in seconds
164         :return: T/F
165         """
166         try:
167             return self._volume_status_check(
168                 STATUS_DELETED, block, VOLUME_DELETE_TIMEOUT, poll_interval)
169         except NotFound as e:
170             logger.debug(
171                 "Volume not found when querying status for %s with message "
172                 "%s", STATUS_DELETED, e)
173             return True
174
175     def _volume_status_check(self, expected_status_code, block, timeout,
176                              poll_interval):
177         """
178         Returns true when the volume status returns the value of
179         expected_status_code
180         :param expected_status_code: instance status evaluated with this string
181                                      value
182         :param block: When true, thread will block until active or timeout
183                       value in seconds has been exceeded (False)
184         :param timeout: The timeout value
185         :param poll_interval: The polling interval in seconds
186         :return: T/F
187         """
188         # sleep and wait for volume status change
189         if block:
190             start = time.time()
191         else:
192             start = time.time() - timeout + 1
193
194         while timeout > time.time() - start:
195             status = self._status(expected_status_code)
196             if status:
197                 logger.debug('Volume is active with name - %s',
198                              self.volume_settings.name)
199                 return True
200
201             logger.debug('Retry querying volume status in %s seconds',
202                          str(poll_interval))
203             time.sleep(poll_interval)
204             logger.debug('Volume status query timeout in %s',
205                          str(timeout - (time.time() - start)))
206
207         logger.error(
208             'Timeout checking for volume status for ' + expected_status_code)
209         return False
210
211     def _status(self, expected_status_code):
212         """
213         Returns True when active else False
214         :param expected_status_code: instance status evaluated with this string
215                                      value
216         :return: T/F
217         """
218         status = cinder_utils.get_volume_status(self._cinder, self.__volume)
219         if not status:
220             logger.warning(
221                 'Cannot volume status for volume with ID - %s',
222                 self.__volume.id)
223             return False
224
225         if status == 'ERROR':
226             raise VolumeCreationError(
227                 'Instance had an error during deployment')
228         logger.debug('Instance status is - ' + status)
229         return status == expected_status_code
230
231
232 class VolumeSettings(VolumeConfig):
233     """
234     Class to hold the configuration settings required for creating OpenStack
235     Volume Type Encryption objects
236     deprecated
237     """
238
239     def __init__(self, **kwargs):
240         from warnings import warn
241         warn('Use snaps.config.volume.VolumeConfig instead',
242              DeprecationWarning)
243         super(self.__class__, self).__init__(**kwargs)
244
245
246 class VolumeCreationError(Exception):
247     """
248     Exception to be thrown when an volume cannot be created
249     """
250
251     def __init__(self, message):
252         Exception.__init__(self, message)