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