def resize_flavor(self, new_flavor_id):
        self.validate_can_perform_action()
        LOG.debug("resizing instance %s flavor to %s"
                  % (self.id, new_flavor_id))
        # Validate that the flavor can be found and that it isn't the same size
        # as the current one.
        client = create_nova_client(self.context)
        try:
            new_flavor = client.flavors.get(new_flavor_id)
        except nova_exceptions.NotFound:
            raise exception.FlavorNotFound(uuid=new_flavor_id)
        old_flavor = client.flavors.get(self.flavor_id)
        new_flavor_size = new_flavor.ram
        old_flavor_size = old_flavor.ram
        if CONF.reddwarf_volume_support:
            if new_flavor.ephemeral != 0:
                raise exception.LocalStorageNotSupported()
            if new_flavor_size == old_flavor_size:
                raise exception.CannotResizeToSameSize()
        elif CONF.device_path is not None:
            # ephemeral support enabled
            if new_flavor.ephemeral == 0:
                raise exception.LocalStorageNotSpecified(flavor=new_flavor_id)
            if (new_flavor_size == old_flavor_size and
                    new_flavor.ephemeral == new_flavor.ephemeral):
                raise exception.CannotResizeToSameSize()

        # Set the task to RESIZING and begin the async call before returning.
        self.update_db(task_status=InstanceTasks.RESIZING)
        LOG.debug("Instance %s set to RESIZING." % self.id)
        task_api.API(self.context).resize_flavor(self.id, new_flavor_id,
                                                 old_flavor_size,
                                                 new_flavor_size)

    def create(cls, context, name, flavor_id, image_id,
               databases, users, service_type, volume_size):
        client = create_nova_client(context)
        try:
            flavor = client.flavors.get(flavor_id)
        except nova_exceptions.NotFound:
            raise exception.FlavorNotFound(uuid=flavor_id)

        db_info = DBInstance.create(name=name, flavor_id=flavor_id,
                                    tenant_id=context.tenant,
                                    volume_size=volume_size,
                                    task_status=InstanceTasks.BUILDING)
        LOG.debug(_("Tenant %s created new Reddwarf instance %s...")
                  % (context.tenant, db_info.id))

        service_status = InstanceServiceStatus.create(
            instance_id=db_info.id,
            status=ServiceStatuses.NEW)

        dns_support = config.Config.get("reddwarf_dns_support", 'False')
        if utils.bool_from_string(dns_support):
            dns_client = create_dns_client(context)
            hostname = dns_client.determine_hostname(db_info.id)
            db_info.hostname = hostname
            db_info.save()

        task_api.API(context).create_instance(db_info.id, name, flavor_id,
                                              flavor.ram, image_id, databases,
                                              users, service_type,
                                              volume_size)

        return SimpleInstance(context, db_info, service_status)

    def _create_server_volume(self, flavor_id, image_id, service_type,
                              volume_size):
        server = None
        try:
            nova_client = create_nova_client(self.context)
            files = {"/etc/guest_info": "--guest_id=%s\n--service_type=%s\n" %
                                        (self.id, service_type)}
            name = self.hostname or self.name
            volume_desc = ("mysql volume for %s" % self.id)
            volume_name = ("mysql-%s" % self.id)
            volume_ref = {'size': volume_size, 'name': volume_name,
                          'description': volume_desc}

            server = nova_client.servers.create(name, image_id, flavor_id,
                                                files=files, volume=volume_ref)
            LOG.debug(_("Created new compute instance %s.") % server.id)

            server_dict = server._info
            LOG.debug("Server response: %s" % server_dict)
            volume_id = None
            for volume in server_dict.get('os:volumes', []):
                volume_id = volume.get('id')

            # Record the server ID and volume ID in case something goes wrong.
            self.update_db(compute_instance_id=server.id, volume_id=volume_id)
        except Exception as e:
            msg = "Error creating server and volume for instance."
            err = inst_models.InstanceTasks.BUILDING_ERROR_SERVER
            self._log_and_raise(e, msg, err)

        device_path = config.Config.get('device_path', '/dev/vdb')
        mount_point = config.Config.get('mount_point', '/var/lib/mysql')
        volume_info = {'device_path': device_path, 'mount_point': mount_point}

        return server, volume_info

    def _create_dns_entry(self):
        LOG.debug("%s: Creating dns entry for instance: %s"
                  % (greenthread.getcurrent(), self.id))
        dns_client = create_dns_client(self.context)
        dns_support = config.Config.get("reddwarf_dns_support", 'False')
        LOG.debug(_("reddwarf dns support = %s") % dns_support)

        nova_client = create_nova_client(self.context)
        if utils.bool_from_string(dns_support):

            def get_server():
                c_id = self.db_info.compute_instance_id
                return nova_client.servers.get(c_id)

            def ip_is_available(server):
                LOG.info("Polling for ip addresses: $%s " % server.addresses)
                if server.addresses != {}:
                    return True
                elif server.addresses == {} and\
                     server.status != InstanceStatus.ERROR:
                    return False
                elif server.addresses == {} and\
                     server.status == InstanceStatus.ERROR:
                    LOG.error(_("Instance IP not available, instance (%s): "
                                "server had status (%s).")
                    % (self.id, server.status))
                    raise ReddwarfError(status=server.status)
            poll_until(get_server, ip_is_available,
                       sleep_time=1, time_out=60 * 2)
            server = nova_client.servers.get(self.db_info.compute_instance_id)
            LOG.info("Creating dns entry...")
            dns_client.create_instance_entry(self.id,
                                             get_ip_address(server.addresses))

    def load(context):

        def load_simple_instance(context, db, status):
            return SimpleInstance(context, db, status)

        if context is None:
            raise TypeError("Argument context not defined.")
        client = create_nova_client(context)
        servers = client.servers.list()

        db_infos = DBInstance.find_all(tenant_id=context.tenant, deleted=False)
        limit = int(context.limit or Instances.DEFAULT_LIMIT)
        if limit > Instances.DEFAULT_LIMIT:
            limit = Instances.DEFAULT_LIMIT
        data_view = DBInstance.find_by_pagination('instances', db_infos, "foo",
                                                  limit=limit,
                                                  marker=context.marker)
        next_marker = data_view.next_page_marker

        find_server = create_server_list_matcher(servers)
        for db in db_infos:
            LOG.debug("checking for db [id=%s, compute_instance_id=%s]" %
                      (db.id, db.compute_instance_id))
        ret = Instances._load_servers_status(load_simple_instance, context,
                                             data_view.collection,
                                             find_server)
        return ret, next_marker

    def create(cls, context, name, flavor_ref, image_id,
               databases, service_type, volume_size):
        db_info = DBInstance.create(name=name,
            task_status=InstanceTasks.NONE)
        LOG.debug(_("Created new Reddwarf instance %s...") % db_info.id)
        volume, volume_info = cls._create_volume(context,
                                                     db_info,
                                                     volume_size)
        client = create_nova_client(context)
        files = {"/etc/guest_info": "guest_id=%s\nservice_type=%s\n" %
                 (db_info.id, service_type)}
        server = client.servers.create(name, image_id, flavor_ref,
                     files=files,
                     block_device_mapping=volume_info['block_device'])
        LOG.debug(_("Created new compute instance %s.") % server.id)

        db_info.compute_instance_id = server.id
        db_info.save()
        service_status = InstanceServiceStatus.create(instance_id=db_info.id,
            status=ServiceStatuses.NEW)
        # Now wait for the response from the create to do additional work

        guest = create_guest_client(context, db_info.id)

        # populate the databases
        model_schemas = populate_databases(databases)
        guest.prepare(512, model_schemas, users=[],
                      device_path=volume_info['device_path'],
                      mount_point=volume_info['mount_point'])
        return Instance(context, db_info, server, service_status, volume)

 def load(context, id):
     client = create_nova_client(context)
     account = client.accounts.get_instances(id)
     db_infos = DBInstance.find_all(tenant_id=id, deleted=False)
     servers = [Server(server) for server in account.servers]
     instances = MgmtInstances.load_status_from_existing(context, db_infos,
                                                         servers)
     return Account(id, instances)

 def _create_server(self, flavor_id, image_id, service_type, block_device_mapping):
     nova_client = create_nova_client(self.context)
     files = {"/etc/guest_info": "guest_id=%s\nservice_type=%s\n" % (self.id, service_type)}
     name = self.hostname or self.name
     bdmap = block_device_mapping
     server = nova_client.servers.create(name, image_id, flavor_id, files=files, block_device_mapping=bdmap)
     LOG.debug(_("Created new compute instance %s.") % server.id)
     return server

    def load(context):
        if context is None:
            raise TypeError("Argument context not defined.")
        client = create_nova_client(context)
        servers = client.servers.list()
        volume_client = create_nova_volume_client(context)
        try:
            volumes = volume_client.volumes.list(detailed=False)
        except nova_exceptions.NotFound:
            volumes = []

        db_infos = DBInstance.find_all()
        limit = int(context.limit or Instances.DEFAULT_LIMIT)
        if limit > Instances.DEFAULT_LIMIT:
            limit = Instances.DEFAULT_LIMIT
        data_view = DBInstance.find_by_pagination('instances', db_infos, "foo",
                                                  limit=limit,
                                                  marker=context.marker)
        next_marker = data_view.next_page_marker

        ret = []
        find_server = create_server_list_matcher(servers)
        find_volumes = create_volumes_list_matcher(volumes)
        for db in db_infos:
            LOG.debug("checking for db [id=%s, compute_instance_id=%s]" %
                      (db.id, db.compute_instance_id))
        for db in data_view.collection:
            try:
                # TODO(hub-cap): Figure out if this is actually correct.
                # We are not sure if we should be doing some validation.
                # Basically if the server find returns nothing, but we
                # have something, there is a mismatch between what the
                # nova db has compared to what we have. We should have
                # a way to handle this.
                server = find_server(db.id, db.compute_instance_id)
                volumes = find_volumes(server.id)
                status = InstanceServiceStatus.find_by(instance_id=db.id)
                LOG.info(_("Server api_status(%s)") %
                           (status.status.api_status))

                if not status.status:
                    LOG.info(_("Server status could not be read for "
                               "instance id(%s)") % (db.compute_instance_id))
                    continue
                if status.status.api_status in ['SHUTDOWN']:
                    LOG.info(_("Server was shutdown id(%s)") %
                           (db.compute_instance_id))
                    continue
            except rd_exceptions.ComputeInstanceNotFound:
                LOG.info(_("Could not find server %s") %
                           db.compute_instance_id)
                continue
            except ModelNotFoundError:
                LOG.info(_("Status entry not found either failed to start "
                           "or instance was deleted"))
                continue
            ret.append(Instance(context, db, server, status, volumes))
        return ret, next_marker

 def load_all(context):
     client = create_nova_client(context)
     LOG.debug("Client.rdhosts=" + str(client.rdhosts))
     rdhosts = client.rdhosts.list()
     LOG.debug("RDHOSTS=" + str(rdhosts))
     for rdhost in rdhosts:
         LOG.debug("rdhost=" + str(rdhost))
     return [SimpleHost(rdhost.name, rdhost.instanceCount)
             for rdhost in rdhosts]

def load_server(context, instance_id, server_id):
    """Loads a server or raises an exception."""
    client = create_nova_client(context)
    try:
        server = client.servers.get(server_id)
        volumes = load_volumes(context, server_id, client=client)
    except nova_exceptions.NotFound, e:
        LOG.debug("Could not find nova server_id(%s)" % server_id)
        raise rd_exceptions.ComputeInstanceNotFound(instance_id=instance_id,
                                                  server_id=server_id)

def load_server(context, instance_id, server_id):
    """Loads a server or raises an exception."""
    client = create_nova_client(context)
    try:
        server = client.servers.get(server_id)
    except nova_exceptions.NotFound as e:
        LOG.debug("Could not find nova server_id(%s)" % server_id)
        raise exception.ComputeInstanceNotFound(instance_id=instance_id, server_id=server_id)
    except nova_exceptions.ClientException, e:
        raise exception.ReddwarfError(str(e))

def load_mgmt_instances(context, deleted=None):
    client = create_nova_client(context)
    mgmt_servers = client.rdservers.list()
    db_infos = None
    if deleted is not None:
        db_infos = instance_models.DBInstance.find_all(deleted=deleted)
    else:
        db_infos = instance_models.DBInstance.find_all()
    instances = MgmtInstances.load_status_from_existing(context, db_infos, mgmt_servers)
    return instances

 def __init__(self, flavor=None, context=None, flavor_id=None):
     if flavor:
         self.flavor = flavor
         return
     if flavor_id and context:
         try:
             client = create_nova_client(context)
             self.flavor = client.flavors.get(flavor_id)
         except nova_exceptions.NotFound, e:
             raise exception.NotFound(uuid=flavor_id)
         except nova_exceptions.ClientException, e:
             raise exception.ReddwarfError(str(e))

def load_mgmt_instance(cls, context, id):
    try:
        instance = load_instance(cls, context, id, needs_server=True)
        client = create_nova_client(context)
        server = client.rdservers.get(instance.server_id)
        instance.server.host = server.host
        instance.server.deleted = server.deleted
        instance.server.deleted_at = server.deleted_at
        instance.server.local_id = server.local_id
        assert instance.server is not None
    except Exception as e:
        LOG.error(e)
        instance = load_instance(cls, context, id, needs_server=False)
    return instance

def load_simple_instance_server_status(context, db_info):
    """Loads a server or raises an exception."""
    if 'BUILDING' == db_info.task_status.action:
        db_info.server_status = "BUILD"
        db_info.addresses = {}
    else:
        client = create_nova_client(context)
        try:
            server = client.servers.get(db_info.compute_instance_id)
            db_info.server_status = server.status
            db_info.addresses = server.addresses
        except nova_exceptions.NotFound, e:
            db_info.server_status = "SHUTDOWN"
            db_info.addresses = {}

        def _create_resources():
            client = create_nova_client(context)
            security_groups = None
            try:
                flavor = client.flavors.get(flavor_id)
            except nova_exceptions.NotFound:
                raise exception.FlavorNotFound(uuid=flavor_id)

            if backup_id is not None:
                backup_info = Backup.get_by_id(backup_id)
                if backup_info.is_running:
                    raise exception.BackupNotCompleteError(backup_id=backup_id)

                location = backup_info.location
                LOG.info(_("Checking if backup exist in '%s'") % location)
                if not Backup.check_object_exist(context, location):
                    raise exception.BackupFileNotFound(location=location)

            db_info = DBInstance.create(name=name, flavor_id=flavor_id,
                                        tenant_id=context.tenant,
                                        volume_size=volume_size,
                                        task_status=InstanceTasks.BUILDING)
            LOG.debug(_("Tenant %s created new Reddwarf instance %s...")
                      % (context.tenant, db_info.id))

            service_status = InstanceServiceStatus.create(
                instance_id=db_info.id,
                status=ServiceStatuses.NEW)

            if CONF.reddwarf_dns_support:
                dns_client = create_dns_client(context)
                hostname = dns_client.determine_hostname(db_info.id)
                db_info.hostname = hostname
                db_info.save()

            if CONF.reddwarf_security_groups_support:
                security_group = SecurityGroup.create_for_instance(
                    db_info.id,
                    context)
                security_groups = [security_group["name"]]

            task_api.API(context).create_instance(db_info.id, name, flavor_id,
                                                  flavor.ram, image_id,
                                                  databases, users,
                                                  service_type, volume_size,
                                                  security_groups, backup_id)

            return SimpleInstance(context, db_info, service_status)

def load_mgmt_instances(context, deleted=None, client=None):
    if not client:
        client = remote.create_nova_client(context)
    try:
        mgmt_servers = client.rdservers.list()
    except AttributeError:
        mgmt_servers = client.servers.list(search_opts={'all_tenants': 1})
    LOG.info("Found %d servers in Nova" %
             len(mgmt_servers if mgmt_servers else []))
    if deleted is not None:
        db_infos = instance_models.DBInstance.find_all(deleted=deleted)
    else:
        db_infos = instance_models.DBInstance.find_all()
    instances = MgmtInstances.load_status_from_existing(context, db_infos,
                                                        mgmt_servers)
    return instances

    def resize_flavor(self, new_flavor_id):
        self._validate_can_perform_action()
        LOG.debug("resizing instance %s flavor to %s" % (self.id, new_flavor_id))
        # Validate that the flavor can be found and that it isn't the same size
        # as the current one.
        client = create_nova_client(self.context)
        try:
            new_flavor = client.flavors.get(new_flavor_id)
        except nova_exceptions.NotFound:
            raise exception.FlavorNotFound(uuid=new_flavor_id)
        old_flavor = client.flavors.get(self.flavor_id)
        new_flavor_size = new_flavor.ram
        old_flavor_size = old_flavor.ram
        if new_flavor_size == old_flavor_size:
            raise exception.CannotResizeToSameSize()

        # Set the task to RESIZING and begin the async call before returning.
        self.update_db(task_status=InstanceTasks.RESIZING)
        LOG.debug("Instance %s set to RESIZING." % self.id)
        task_api.API(self.context).resize_flavor(self.id, new_flavor_id, old_flavor_size, new_flavor_size)

def load_volumes(context, server_id, client=None):
    volume_support = config.Config.get("reddwarf_volume_support", 'False')
    if utils.bool_from_string(volume_support):
        if client is None:
            client = create_nova_client(context)
        volume_client = create_nova_volume_client(context)
        try:
            volumes = []
            volumes_info = client.volumes.get_server_volumes(server_id)
            volume_ids = [attachments.volumeId for attachments in
                          volumes_info]
            for volume_id in volume_ids:
                volume_info = volume_client.volumes.get(volume_id)
                volume = {'id': volume_info.id,
                          'size': volume_info.size}
                volumes.append(volume)
        except nova_exceptions.NotFound, e:
            LOG.debug("Could not find nova server_id(%s)" % server_id)
            raise rd_exceptions.VolumeAttachmentsNotFound(server_id=server_id)
        except nova_exceptions.ClientException, e:
            raise rd_exceptions.ReddwarfError(str(e))