snaps/openstack/create_instance.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 import logging
  16 import time
  17
  18 from novaclient.exceptions import NotFound
  19
  20 from snaps.config.vm_inst import VmInstanceConfig, FloatingIpConfig
  21 from snaps.openstack.openstack_creator import OpenStackComputeObject
  22 from snaps.openstack.utils import (
  23     glance_utils, cinder_utils, settings_utils, keystone_utils)
  24 from snaps.openstack.utils import neutron_utils
  25 from snaps.openstack.utils import nova_utils
  26 from snaps.openstack.utils.nova_utils import RebootType
  27 from snaps.provisioning import ansible_utils
  28
  29 __author__ = 'spisarski'
  30
  31 logger = logging.getLogger('create_instance')
  32
  33 POLL_INTERVAL = 3
  34 STATUS_ACTIVE = 'ACTIVE'
  35 STATUS_DELETED = 'DELETED'
  36
  37
  38 class OpenStackVmInstance(OpenStackComputeObject):
  39     """
  40     Class responsible for managing a VM instance in OpenStack
  41     """
  42
  43     def __init__(self, os_creds, instance_settings, image_settings,
  44                  keypair_settings=None):
  45         """
  46         Constructor
  47         :param os_creds: The connection credentials to the OpenStack API
  48         :param instance_settings: Contains the settings for this VM
  49         :param image_settings: The OpenStack image object settings
  50         :param keypair_settings: The keypair metadata (Optional)
  51         :raises Exception
  52         """
  53         super(self.__class__, self).__init__(os_creds)
  54
  55         self.__neutron = None
  56
  57         self.instance_settings = instance_settings
  58         self.image_settings = image_settings
  59         self.keypair_settings = keypair_settings
  60
  61         self.__floating_ip_dict = dict()
  62
  63         # Instantiated in self.create()
  64         self.__ports = list()
  65
  66         # Note: this object does not change after the VM becomes active
  67         self.__vm = None
  68
  69     def initialize(self):
  70         """
  71         Loads the existing VMInst, Port, FloatingIps
  72         :return: VMInst domain object
  73         """
  74         super(self.__class__, self).initialize()
  75
  76         self.__neutron = neutron_utils.neutron_client(self._os_creds)
  77         self.__keystone = keystone_utils.keystone_client(self._os_creds)
  78
  79         self.__ports = self.__query_ports(self.instance_settings.port_settings)
  80         self.__lookup_existing_vm_by_name()
  81
  82     def create(self, block=False):
  83         """
  84         Creates a VM instance and associated objects unless they already exist
  85         :param block: Thread will block until instance has either become
  86                       active, error, or timeout waiting.
  87                       Additionally, when True, floating IPs will not be applied
  88                       until VM is active.
  89         :return: VMInst domain object
  90         """
  91         self.initialize()
  92
  93         if len(self.__ports) == 0:
  94             self.__ports = self.__create_ports(
  95                 self.instance_settings.port_settings)
  96         if not self.__vm:
  97             self.__create_vm(block)
  98
  99         return self.__vm
 100
 101     def __lookup_existing_vm_by_name(self):
 102         """
 103         Populates the member variables 'self.vm' and 'self.floating_ips' if a
 104         VM with the same name already exists
 105         within the project
 106         """
 107         server = nova_utils.get_server(
 108             self._nova, self.__neutron, self.__keystone,
 109             vm_inst_settings=self.instance_settings)
 110         if server:
 111             if server.name == self.instance_settings.name:
 112                 self.__vm = server
 113                 logger.info(
 114                     'Found existing machine with name - %s',
 115                     self.instance_settings.name)
 116
 117                 fips = neutron_utils.get_port_floating_ips(
 118                     self.__neutron, self.__ports)
 119                 for port_id, fip in fips:
 120                     settings = self.instance_settings.floating_ip_settings
 121                     for fip_setting in settings:
 122                         if port_id == fip_setting.port_id:
 123                             self.__floating_ip_dict[fip_setting.name] = fip
 124                         else:
 125                             port = neutron_utils.get_port_by_id(
 126                                 self.__neutron, port_id)
 127                             if port and port.name == fip_setting.port_name:
 128                                 self.__floating_ip_dict[fip_setting.name] = fip
 129
 130     def __create_vm(self, block=False):
 131         """
 132         Responsible for creating the VM instance
 133         :param block: Thread will block until instance has either become
 134                       active, error, or timeout waiting. Floating IPs will be
 135                       assigned after active when block=True
 136         """
 137         glance = glance_utils.glance_client(self._os_creds)
 138         self.__vm = nova_utils.create_server(
 139             self._nova, self.__keystone, self.__neutron, glance,
 140             self.instance_settings, self.image_settings,
 141             self._os_creds.project_name, self.keypair_settings)
 142         logger.info('Created instance with name - %s',
 143                     self.instance_settings.name)
 144
 145         if block:
 146             if not self.vm_active(block=True):
 147                 raise VmInstanceCreationError(
 148                     'Fatal error, VM did not become ACTIVE within the alloted '
 149                     'time')
 150
 151         # Create server should do this but found it needed to occur here
 152         for sec_grp_name in self.instance_settings.security_group_names:
 153             if self.vm_active(block=True):
 154                 nova_utils.add_security_group(self._nova, self.__vm,
 155                                               sec_grp_name)
 156             else:
 157                 raise VmInstanceCreationError(
 158                     'Cannot applying security group with name ' +
 159                     sec_grp_name +
 160                     ' to VM that did not activate with name - ' +
 161                     self.instance_settings.name)
 162
 163         if self.instance_settings.volume_names:
 164             for volume_name in self.instance_settings.volume_names:
 165                 cinder = cinder_utils.cinder_client(self._os_creds)
 166                 volume = cinder_utils.get_volume(
 167                     cinder, self.__keystone, volume_name=volume_name,
 168                     project_name=self._os_creds.project_name)
 169
 170                 if volume and self.vm_active(block=True):
 171                     vm = nova_utils.attach_volume(
 172                         self._nova, self.__neutron, self.__keystone, self.__vm,
 173                         volume, self._os_creds.project_name)
 174
 175                     if vm:
 176                         self.__vm = vm
 177                     else:
 178                         logger.warn(
 179                             'Volume [%s] attachment timeout ', volume.name)
 180                 else:
 181                     logger.warn('Unable to attach volume named [%s]',
 182                                 volume_name)
 183
 184         self.__apply_floating_ips()
 185
 186     def __apply_floating_ips(self):
 187         """
 188         Applies the configured floating IPs to the necessary ports
 189         """
 190         port_dict = dict()
 191         for key, port in self.__ports:
 192             port_dict[key] = port
 193
 194         # Apply floating IPs
 195         for floating_ip_setting in self.instance_settings.floating_ip_settings:
 196             self.add_floating_ip(floating_ip_setting)
 197
 198     def add_floating_ip(self, floating_ip_setting):
 199         """
 200         Adds a floating IP to a running instance
 201         :param floating_ip_setting - the floating IP configuration
 202         :return: the floating ip object
 203         """
 204         port_dict = dict()
 205         for key, port in self.__ports:
 206             port_dict[key] = port
 207
 208         # Apply floating IP
 209         port = port_dict.get(floating_ip_setting.port_name)
 210
 211         if not port:
 212             raise VmInstanceCreationError(
 213                 'Cannot find port object with name - ' +
 214                 floating_ip_setting.port_name)
 215
 216         # Setup Floating IP only if there is a router with an external
 217         # gateway
 218         ext_gateway = self.__ext_gateway_by_router(
 219             floating_ip_setting.router_name)
 220         if ext_gateway and self.vm_active(block=True):
 221             floating_ip = neutron_utils.create_floating_ip(
 222                 self.__neutron, self.__keystone, ext_gateway, port.id)
 223             self.__floating_ip_dict[floating_ip_setting.name] = floating_ip
 224
 225             logger.info(
 226                 'Created floating IP %s via router - %s', floating_ip.ip,
 227                 floating_ip_setting.router_name)
 228
 229             return floating_ip
 230         else:
 231             raise VmInstanceCreationError(
 232                 'Unable to add floating IP to port, cannot locate router '
 233                 'with an external gateway ')
 234
 235     def __ext_gateway_by_router(self, router_name):
 236         """
 237         Returns network name for the external network attached to a router or
 238         None if not found
 239         :param router_name: The name of the router to lookup
 240         :return: the external network name or None
 241         """
 242         router = neutron_utils.get_router(
 243             self.__neutron, self.__keystone, router_name=router_name,
 244             project_name=self._os_creds.project_name)
 245         if router and router.external_network_id:
 246             network = neutron_utils.get_network_by_id(
 247                 self.__neutron, router.external_network_id)
 248             if network:
 249                 return network.name
 250         return None
 251
 252     def clean(self):
 253         """
 254         Destroys the VM instance
 255         """
 256
 257         # Cleanup floating IPs
 258         for name, floating_ip in self.__floating_ip_dict.items():
 259             logger.info('Deleting Floating IP - ' + floating_ip.ip)
 260             neutron_utils.delete_floating_ip(self.__neutron, floating_ip)
 261
 262         self.__floating_ip_dict = dict()
 263
 264         # Cleanup ports
 265         for name, port in self.__ports:
 266             logger.info('Deleting Port with ID - %s ', port.id)
 267             neutron_utils.delete_port(self.__neutron, port)
 268
 269         self.__ports = list()
 270
 271         if self.__vm:
 272             # Detach Volume
 273             for volume_rec in self.__vm.volume_ids:
 274                 cinder = cinder_utils.cinder_client(self._os_creds)
 275                 volume = cinder_utils.get_volume_by_id(
 276                     cinder, volume_rec['id'])
 277                 if volume:
 278                     vm = nova_utils.detach_volume(
 279                         self._nova, self.__neutron, self.__keystone, self.__vm,
 280                         volume, self._os_creds.project_name)
 281                     if vm:
 282                         self.__vm = vm
 283                     else:
 284                         logger.warn(
 285                             'Timeout waiting to detach volume %s', volume.name)
 286                 else:
 287                     logger.warn('Unable to detach volume with ID - [%s]',
 288                                 volume_rec['id'])
 289
 290             # Cleanup VM
 291             logger.info(
 292                 'Deleting VM instance - ' + self.instance_settings.name)
 293
 294             try:
 295                 nova_utils.delete_vm_instance(self._nova, self.__vm)
 296             except NotFound as e:
 297                 logger.warn('Instance already deleted - %s', e)
 298
 299             # Block until instance cannot be found or returns the status of
 300             # DELETED
 301             logger.info('Checking deletion status')
 302
 303             if self.vm_deleted(block=True):
 304                 logger.info(
 305                     'VM has been properly deleted VM with name - %s',
 306                     self.instance_settings.name)
 307                 self.__vm = None
 308             else:
 309                 logger.error(
 310                     'VM not deleted within the timeout period of %s '
 311                     'seconds', self.instance_settings.vm_delete_timeout)
 312
 313     def __query_ports(self, port_settings):
 314         """
 315         Returns the previously configured ports or an empty list if none
 316         exist
 317         :param port_settings: A list of PortSetting objects
 318         :return: a list of OpenStack port tuples where the first member is the
 319                  port name and the second is the port object
 320         """
 321         ports = list()
 322
 323         for port_setting in port_settings:
 324             port = neutron_utils.get_port(
 325                 self.__neutron, self.__keystone, port_settings=port_setting,
 326                 project_name=self._os_creds.project_name)
 327             if port:
 328                 ports.append((port_setting.name, port))
 329
 330         return ports
 331
 332     def __create_ports(self, port_settings):
 333         """
 334         Returns the previously configured ports or creates them if they do not
 335         exist
 336         :param port_settings: A list of PortSetting objects
 337         :return: a list of OpenStack port tuples where the first member is the
 338                  port name and the second is the port object
 339         """
 340         ports = list()
 341
 342         for port_setting in port_settings:
 343             port = neutron_utils.get_port(
 344                 self.__neutron, self.__keystone, port_settings=port_setting)
 345             if not port:
 346                 port = neutron_utils.create_port(
 347                     self.__neutron, self._os_creds, port_setting)
 348                 if port:
 349                     ports.append((port_setting.name, port))
 350
 351         return ports
 352
 353     def get_os_creds(self):
 354         """
 355         Returns the OpenStack credentials used to create these objects
 356         :return: the credentials
 357         """
 358         return self._os_creds
 359
 360     def get_vm_inst(self):
 361         """
 362         Returns the latest version of this server object from OpenStack
 363         :return: Server object
 364         """
 365         return nova_utils.get_server_object_by_id(
 366             self._nova, self.__neutron, self.__keystone, self.__vm.id,
 367             self._os_creds.project_name)
 368
 369     def get_console_output(self):
 370         """
 371         Returns the vm console object for parsing logs
 372         :return: the console output object
 373         """
 374         return nova_utils.get_server_console_output(self._nova, self.__vm)
 375
 376     def get_port_ip(self, port_name, subnet_name=None):
 377         """
 378         Returns the first IP for the port corresponding with the port_name
 379         parameter when subnet_name is None else returns the IP address that
 380         corresponds to the subnet_name parameter
 381         :param port_name: the name of the port from which to return the IP
 382         :param subnet_name: the name of the subnet attached to this IP
 383         :return: the IP or None if not found
 384         """
 385         port = self.get_port_by_name(port_name)
 386         if port:
 387             if subnet_name:
 388                 subnet = neutron_utils.get_subnet(
 389                     self.__neutron, subnet_name=subnet_name)
 390                 if not subnet:
 391                     logger.warning('Cannot retrieve port IP as subnet could '
 392                                    'not be located with name - %s',
 393                                    subnet_name)
 394                     return None
 395                 for fixed_ip in port.ips:
 396                     if fixed_ip['subnet_id'] == subnet.id:
 397                         return fixed_ip['ip_address']
 398             else:
 399                 if port.ips and len(port.ips) > 0:
 400                     return port.ips[0]['ip_address']
 401         return None
 402
 403     def get_port_mac(self, port_name):
 404         """
 405         Returns the first IP for the port corresponding with the port_name
 406         parameter
 407         TODO - Add in the subnet as an additional parameter as a port may have
 408         multiple fixed_ips
 409         :param port_name: the name of the port from which to return the IP
 410         :return: the IP or None if not found
 411         """
 412         port = self.get_port_by_name(port_name)
 413         if port:
 414             return port.mac_address
 415         return None
 416
 417     def get_port_by_name(self, port_name):
 418         """
 419         Retrieves the OpenStack port object by its given name
 420         :param port_name: the name of the port
 421         :return: the OpenStack port object or None if not exists
 422         """
 423         for key, port in self.__ports:
 424             if key == port_name:
 425                 return port
 426         logger.warning('Cannot find port with name - ' + port_name)
 427         return None
 428
 429     def get_vm_info(self):
 430         """
 431         Returns a dictionary of a VMs info as returned by OpenStack
 432         :return: a dict()
 433         """
 434         return nova_utils.get_server_info(self._nova, self.__vm)
 435
 436     def __get_first_provisioning_floating_ip(self):
 437         """
 438         Returns the first floating IP tagged with the Floating IP name if
 439         exists else the first one found
 440         :return:
 441         """
 442         for floating_ip_setting in self.instance_settings.floating_ip_settings:
 443             if floating_ip_setting.provisioning:
 444                 fip = self.__floating_ip_dict.get(floating_ip_setting.name)
 445                 if fip:
 446                     return fip
 447                 elif len(self.__floating_ip_dict) > 0:
 448                     for key, fip in self.__floating_ip_dict.items():
 449                         return fip
 450
 451         # When cannot be found above
 452         if len(self.__floating_ip_dict) > 0:
 453             for key, fip in self.__floating_ip_dict.items():
 454                 return fip
 455
 456     def apply_ansible_playbook(self, pb_file_loc, variables=None,
 457                                fip_name=None):
 458         """
 459         Applies a playbook to a VM
 460         :param pb_file_loc: the file location of the playbook to be applied
 461         :param variables: a dict() of substitution values required by the
 462                           playbook
 463         :param fip_name: the name of the floating IP to use for applying the
 464                          playbook (default - will take the first)
 465         :return: the return value from ansible
 466         """
 467         return ansible_utils.apply_playbook(
 468             pb_file_loc, [self.get_floating_ip(fip_name=fip_name).ip],
 469             self.get_image_user(),
 470             ssh_priv_key_file_path=self.keypair_settings.private_filepath,
 471             variables=variables, proxy_setting=self._os_creds.proxy_settings)
 472
 473     def get_image_user(self):
 474         """
 475         Returns the instance sudo_user if it has been configured in the
 476         instance_settings else it returns the image_settings.image_user value
 477         """
 478         if self.instance_settings.sudo_user:
 479             return self.instance_settings.sudo_user
 480         else:
 481             return self.image_settings.image_user
 482
 483     def vm_deleted(self, block=False, poll_interval=POLL_INTERVAL):
 484         """
 485         Returns true when the VM status returns the value of
 486         expected_status_code or instance retrieval throws a NotFound exception.
 487         :param block: When true, thread will block until active or timeout
 488                       value in seconds has been exceeded (False)
 489         :param poll_interval: The polling interval in seconds
 490         :return: T/F
 491         """
 492         try:
 493             return self.__vm_status_check(
 494                 STATUS_DELETED, block,
 495                 self.instance_settings.vm_delete_timeout, poll_interval)
 496         except NotFound as e:
 497             logger.debug(
 498                 "Instance not found when querying status for %s with message "
 499                 "%s", STATUS_DELETED, e)
 500             return True
 501
 502     def vm_active(self, block=False, poll_interval=POLL_INTERVAL):
 503         """
 504         Returns true when the VM status returns the value of the constant
 505         STATUS_ACTIVE
 506         :param block: When true, thread will block until active or timeout
 507                       value in seconds has been exceeded (False)
 508         :param poll_interval: The polling interval in seconds
 509         :return: T/F
 510         """
 511         if self.__vm_status_check(
 512                 STATUS_ACTIVE, block, self.instance_settings.vm_boot_timeout,
 513                 poll_interval):
 514             self.__vm = nova_utils.get_server_object_by_id(
 515                 self._nova, self.__neutron, self.__keystone, self.__vm.id,
 516                 self._os_creds.project_name)
 517             return True
 518         return False
 519
 520     def __vm_status_check(self, expected_status_code, block, timeout,
 521                           poll_interval):
 522         """
 523         Returns true when the VM status returns the value of
 524         expected_status_code
 525         :param expected_status_code: instance status evaluated with this
 526                                      string value
 527         :param block: When true, thread will block until active or timeout
 528                       value in seconds has been exceeded (False)
 529         :param timeout: The timeout value
 530         :param poll_interval: The polling interval in seconds
 531         :return: T/F
 532         """
 533         # sleep and wait for VM status change
 534         if block:
 535             start = time.time()
 536         else:
 537             return self.__status(expected_status_code)
 538
 539         while timeout > time.time() - start:
 540             status = self.__status(expected_status_code)
 541             if status:
 542                 logger.info('VM is - ' + expected_status_code)
 543                 return True
 544
 545             logger.debug('Retry querying VM status in ' + str(
 546                 poll_interval) + ' seconds')
 547             time.sleep(poll_interval)
 548             logger.debug('VM status query timeout in ' + str(
 549                 timeout - (time.time() - start)))
 550
 551         logger.error(
 552             'Timeout checking for VM status for ' + expected_status_code)
 553         return False
 554
 555     def __status(self, expected_status_code):
 556         """
 557         Returns True when active else False
 558         :param expected_status_code: instance status evaluated with this string
 559                                      value
 560         :return: T/F
 561         """
 562         if not self.__vm:
 563             if expected_status_code == STATUS_DELETED:
 564                 return True
 565             else:
 566                 return False
 567
 568         status = nova_utils.get_server_status(self._nova, self.__vm)
 569         if not status:
 570             logger.warning('Cannot find instance with id - ' + self.__vm.id)
 571             return False
 572
 573         if status == 'ERROR':
 574             raise VmInstanceCreationError(
 575                 'Instance had an error during deployment')
 576         logger.debug(
 577             'Instance status [%s] is - %s', self.instance_settings.name,
 578             status)
 579         return status == expected_status_code
 580
 581     def vm_ssh_active(self, user_override=None, password=None, block=False,
 582                       timeout=None, poll_interval=POLL_INTERVAL):
 583         """
 584         Returns true when the VM can be accessed via SSH
 585         :param user_override: overrides the user with which to create the
 586                               connection
 587         :param password: overrides the use of a password instead of a private
 588                          key with which to create the connection
 589         :param block: When true, thread will block until active or timeout
 590                       value in seconds has been exceeded (False)
 591         :param timeout: the number of seconds to retry obtaining the connection
 592                         and overrides the ssh_connect_timeout member of the
 593                         self.instance_settings object
 594         :param poll_interval: The polling interval
 595         :return: T/F
 596         """
 597         # sleep and wait for VM status change
 598         logger.info('Checking if VM is active')
 599
 600         if not timeout:
 601             timeout = self.instance_settings.ssh_connect_timeout
 602
 603         if self.vm_active(block=True):
 604             if block:
 605                 start = time.time()
 606             else:
 607                 start = time.time() - timeout
 608
 609             while timeout > time.time() - start:
 610                 status = self.__ssh_active(
 611                     user_override=user_override, password=password)
 612                 if status:
 613                     logger.info('SSH is active for VM instance')
 614                     return True
 615
 616                 logger.debug('Retry SSH connection in ' + str(
 617                     poll_interval) + ' seconds')
 618                 time.sleep(poll_interval)
 619                 logger.debug('SSH connection timeout in ' + str(
 620                     timeout - (time.time() - start)))
 621
 622         logger.error('Timeout attempting to connect with VM via SSH')
 623         return False
 624
 625     def __ssh_active(self, user_override=None, password=None):
 626         """
 627         Returns True when can create a SSH session else False
 628         :return: T/F
 629         """
 630         if len(self.__floating_ip_dict) > 0:
 631             ssh = self.ssh_client(
 632                 user_override=user_override, password=password)
 633             if ssh:
 634                 ssh.close()
 635                 return True
 636         return False
 637
 638     def cloud_init_complete(self, block=False, poll_interval=POLL_INTERVAL):
 639         """
 640         Returns true when the VM's cloud-init routine has completed.
 641         Note: this is currently done via SSH, therefore, if this instance does
 642               not have a Floating IP or a running SSH server, this routine
 643               will always return False or raise an Exception
 644         :param block: When true, thread will block until active or timeout
 645                       value in seconds has been exceeded (False)
 646         :param poll_interval: The polling interval
 647         :return: T/F
 648         """
 649         # sleep and wait for VM status change
 650         logger.info('Checking if cloud-init has completed')
 651
 652         timeout = self.instance_settings.cloud_init_timeout
 653
 654         if self.vm_active(block=True) and self.vm_ssh_active(block=True):
 655             if block:
 656                 start = time.time()
 657             else:
 658                 start = time.time() - timeout
 659
 660             while timeout > time.time() - start:
 661                 status = self.__cloud_init_complete()
 662                 if status:
 663                     logger.info('cloud-init complete for VM instance')
 664                     return True
 665
 666                 logger.debug('Retry cloud-init query in ' + str(
 667                     poll_interval) + ' seconds')
 668                 time.sleep(poll_interval)
 669                 logger.debug('cloud-init complete timeout in ' + str(
 670                     timeout - (time.time() - start)))
 671
 672         logger.error('Timeout waiting for cloud-init to complete')
 673         return False
 674
 675     def __cloud_init_complete(self):
 676         """
 677         Returns True when can create a SSH session else False
 678         :return: T/F
 679         """
 680         if len(self.__floating_ip_dict) > 0:
 681             ssh = self.ssh_client()
 682             if ssh:
 683                 stdin1, stdout1, sterr1 = ssh.exec_command(
 684                     'ls -l /var/lib/cloud/instance/boot-finished')
 685                 return stdout1.channel.recv_exit_status() == 0
 686         return False
 687
 688     def get_floating_ip(self, fip_name=None):
 689         """
 690         Returns the floating IP object byt name if found, else the first known,
 691         else None
 692         :param fip_name: the name of the floating IP to return
 693         :return: the SSH client or None
 694         """
 695         if fip_name and self.__floating_ip_dict.get(fip_name):
 696             return self.__floating_ip_dict.get(fip_name)
 697         else:
 698             return self.__get_first_provisioning_floating_ip()
 699
 700     def ssh_client(self, fip_name=None, user_override=None, password=None):
 701         """
 702         Returns an SSH client using the name or the first known floating IP if
 703         exists, else None
 704         :param fip_name: the name of the floating IP to return
 705         :param user_override: the username to use instead of the default
 706         :param password: the password to use instead of the private key
 707         :return: the SSH client or None
 708         """
 709         fip = self.get_floating_ip(fip_name)
 710
 711         ansible_user = self.get_image_user()
 712         if user_override:
 713             ansible_user = user_override
 714
 715         if password:
 716             private_key = None
 717         else:
 718             private_key = self.keypair_settings.private_filepath
 719
 720         if fip:
 721             return ansible_utils.ssh_client(
 722                 self.__get_first_provisioning_floating_ip().ip,
 723                 ansible_user,
 724                 private_key_filepath=private_key,
 725                 password=password,
 726                 proxy_settings=self._os_creds.proxy_settings)
 727         else:
 728             FloatingIPAllocationError(
 729                 'Cannot return an SSH client. No Floating IP configured')
 730
 731     def add_security_group(self, security_group):
 732         """
 733         Adds a security group to this VM. Call will block until VM is active.
 734         :param security_group: the SNAPS SecurityGroup domain object
 735         :return True if successful else False
 736         """
 737         self.vm_active(block=True)
 738
 739         if not security_group:
 740             logger.warning('Security group object is None, cannot add')
 741             return False
 742
 743         try:
 744             nova_utils.add_security_group(self._nova, self.get_vm_inst(),
 745                                           security_group.name)
 746             return True
 747         except NotFound as e:
 748             logger.warning('Security group not added - ' + str(e))
 749             return False
 750
 751     def remove_security_group(self, security_group):
 752         """
 753         Removes a security group to this VM. Call will block until VM is active
 754         :param security_group: the OpenStack security group object
 755         :return True if successful else False
 756         """
 757         self.vm_active(block=True)
 758
 759         if not security_group:
 760             logger.warning('Security group object is None, cannot remove')
 761             return False
 762
 763         try:
 764             nova_utils.remove_security_group(self._nova, self.get_vm_inst(),
 765                                              security_group)
 766             return True
 767         except NotFound as e:
 768             logger.warning('Security group not removed - ' + str(e))
 769             return False
 770
 771     def reboot(self, reboot_type=RebootType.soft):
 772         """
 773         Issues a reboot call
 774         :param reboot_type: instance of
 775                             snaps.openstack.utils.nova_utils.RebootType
 776                             enumeration
 777         :return:
 778         """
 779         nova_utils.reboot_server(
 780             self._nova, self.__vm, reboot_type=reboot_type)
 781
 782
 783 def generate_creator(os_creds, vm_inst, image_config, project_name,
 784                      keypair_config=None):
 785     """
 786     Initializes an OpenStackVmInstance object
 787     :param os_creds: the OpenStack credentials
 788     :param vm_inst: the SNAPS-OO VmInst domain object
 789     :param image_config: the associated ImageConfig object
 790     :param project_name: the associated project ID
 791     :param keypair_config: the associated KeypairConfig object (optional)
 792     :return: an initialized OpenStackVmInstance object
 793     """
 794     nova = nova_utils.nova_client(os_creds)
 795     keystone = keystone_utils.keystone_client(os_creds)
 796     neutron = neutron_utils.neutron_client(os_creds)
 797     derived_inst_config = settings_utils.create_vm_inst_config(
 798         nova, keystone, neutron, vm_inst, project_name)
 799
 800     derived_inst_creator = OpenStackVmInstance(
 801         os_creds, derived_inst_config, image_config, keypair_config)
 802     derived_inst_creator.initialize()
 803     return derived_inst_creator
 804
 805
 806 class VmInstanceSettings(VmInstanceConfig):
 807     """
 808     Deprecated, use snaps.config.vm_inst.VmInstanceConfig instead
 809     """
 810     def __init__(self, **kwargs):
 811         from warnings import warn
 812         warn('Use snaps.config.vm_inst.VmInstanceConfig instead',
 813              DeprecationWarning)
 814         super(self.__class__, self).__init__(**kwargs)
 815
 816
 817 class FloatingIpSettings(FloatingIpConfig):
 818     """
 819     Deprecated, use snaps.config.vm_inst.FloatingIpConfig instead
 820     """
 821     def __init__(self, **kwargs):
 822         from warnings import warn
 823         warn('Use snaps.config.vm_inst.FloatingIpConfig instead',
 824              DeprecationWarning)
 825         super(self.__class__, self).__init__(**kwargs)
 826
 827
 828 class VmInstanceCreationError(Exception):
 829     """
 830     Exception to be thrown when an VM instance cannot be created
 831     """
 832
 833
 834 class FloatingIPAllocationError(Exception):
 835     """
 836     Exception to be thrown when an VM instance cannot allocate a floating IP
 837     """