Esempio n. 1
0
        def host_schedule(rpc_method,
                    context, base_options,
                    instance_type,
                    availability_zone, injected_files,
                    admin_password, image,
                    num_instances,
                    requested_networks,
                    block_device_mapping,
                    security_group,
                    filter_properties):

            instance_uuid = base_options.get('uuid')
            now = utils.utcnow()
            self.db.instance_update(context, instance_uuid,
                               {'host': target_host,
                                'scheduled_at': now})

            rpc.cast(context, rpc.queue_get_for(context, CONF.compute_topic, target_host),
                     {"method": "run_instance",
                      "args": {"instance_uuid": instance_uuid,
                       "availability_zone": availability_zone,
                       "admin_password": admin_password,
                       "injected_files": injected_files,
                       "requested_networks": requested_networks}})

            # Instance was already created before calling scheduler
            return self.get(context, instance_uuid)
Esempio n. 2
0
File: api.py Progetto: bhuvan/nova
    def _cast_create_volume(self, context, volume_id,
                            snapshot_id, reservations):

        # NOTE(Rongze Zhu): It is a simple solution for bug 1008866
        # If snapshot_id is set, make the call create volume directly to
        # the volume host where the snapshot resides instead of passing it
        # through the scheduer. So snapshot can be copy to new volume.

        if snapshot_id and FLAGS.snapshot_same_host:
            snapshot_ref = self.db.snapshot_get(context, snapshot_id)
            src_volume_ref = self.db.volume_get(context,
                                                snapshot_ref['volume_id'])
            topic = rpc.queue_get_for(context,
                                      FLAGS.volume_topic,
                                      src_volume_ref['host'])
            rpc.cast(context,
                     topic,
                     {"method": "create_volume",
                      "args": {"volume_id": volume_id,
                               "snapshot_id": snapshot_id}})
        else:
            rpc.cast(context,
                     FLAGS.scheduler_topic,
                     {"method": "create_volume",
                      "args": {"topic": FLAGS.volume_topic,
                               "volume_id": volume_id,
                               "snapshot_id": snapshot_id,
                               "reservations": reservations}})
Esempio n. 3
0
def cast_to_network_host(context, host, method, **kwargs):
    """Cast request to a network host queue"""

    rpc.cast(context,
             rpc.queue_get_for(context, 'network', host),
             {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to network '%(host)s'") % locals())
Esempio n. 4
0
File: api.py Progetto: bhuvan/nova
    def _create_snapshot(self, context, volume, name, description,
                         force=False):
        check_policy(context, 'create_snapshot', volume)

        if ((not force) and (volume['status'] != "available")):
            msg = _("must be available")
            raise exception.InvalidVolume(reason=msg)

        options = {
            'volume_id': volume['id'],
            'user_id': context.user_id,
            'project_id': context.project_id,
            'status': "creating",
            'progress': '0%',
            'volume_size': volume['size'],
            'display_name': name,
            'display_description': description}

        snapshot = self.db.snapshot_create(context, options)
        host = volume['host']
        rpc.cast(context,
                 rpc.queue_get_for(context, FLAGS.volume_topic, host),
                 {"method": "create_snapshot",
                  "args": {"volume_id": volume['id'],
                           "snapshot_id": snapshot['id']}})
        return snapshot
Esempio n. 5
0
    def copy_volume_to_image(self, context, volume, metadata, force):
        """Create a new image from the specified volume."""
        self._check_volume_availability(context, volume, force)

        recv_metadata = self.image_service.create(context, metadata)
        self.update(context, volume, {'status': 'uploading'})
        rpc.cast(context,
                 rpc.queue_get_for(context,
                                   FLAGS.volume_topic,
                                   volume['host']),
                 {"method": "copy_volume_to_image",
                  "args": {"volume_id": volume['id'],
                           "image_id": recv_metadata['id']}})

        response = {"id": volume['id'],
               "updated_at": volume['updated_at'],
               "status": 'uploading',
               "display_description": volume['display_description'],
               "size": volume['size'],
               "volume_type": volume['volume_type'],
               "image_id": recv_metadata['id'],
               "container_format": recv_metadata['container_format'],
               "disk_format": recv_metadata['disk_format'],
               "image_name": recv_metadata.get('name', None)
        }
        return response
Esempio n. 6
0
    def launch_instance(self, context, instance_uuid, params={}):
        pid = context.project_id
        uid = context.user_id

        # TODO(dscannell): Need to figure out how these quota reservations work and what
        # we need to do with them.
        num_instances, reservations = self._check_quota(context, instance_uuid)
        instance = self.get(context, instance_uuid)

        if not(self._is_instance_blessed(context, instance_uuid)):
            # The instance is not blessed. We can't launch new instances from it.
            raise exception.NovaException(
                  _(("Instance %s is not blessed. " +
                     "Please bless the instance before launching from it.") % instance_uuid))

        # Create a new launched instance.
        new_instance_ref = self._copy_instance(context, instance_uuid, "clone", launch=True)

        LOG.debug(_("Casting to scheduler for %(pid)s/%(uid)s's"
                    " instance %(instance_uuid)s") % locals())
        rpc.cast(context,
                     FLAGS.scheduler_topic,
                     {"method": "launch_instance",
                      "args": {"topic": FLAGS.gridcentric_topic,
                               "instance_uuid": new_instance_ref['uuid'],
                               "params": params}})

        return self.get(context, new_instance_ref['uuid'])
Esempio n. 7
0
    def _cast_gridcentric_message(self,
                                  method,
                                  context,
                                  instance_uuid,
                                  host=None,
                                  params=None):
        """Generic handler for RPC casts to gridcentric. This does not block for a response.

        :param params: Optional dictionary of arguments to be passed to the
                       gridcentric worker

        :returns: None
        """

        if not params:
            params = {}
        if not host:
            instance = self.get(context, instance_uuid)
            host = instance['host']
        if not host:
            queue = CONF.gridcentric_topic
        else:
            queue = rpc.queue_get_for(context, CONF.gridcentric_topic, host)

        params['instance_uuid'] = instance_uuid
        kwargs = {'method': method, 'args': params}
        rpc.cast(context, queue, kwargs)
Esempio n. 8
0
File: api.py Progetto: linets/nova
    def _cast_create_volume(self, context, volume_id, snapshot_id,
                            reservations):

        # NOTE(Rongze Zhu): It is a simple solution for bug 1008866
        # If snapshot_id is set, make the call create volume directly to
        # the volume host where the snapshot resides instead of passing it
        # through the scheduer. So snapshot can be copy to new volume.

        if snapshot_id and FLAGS.snapshot_same_host:
            snapshot_ref = self.db.snapshot_get(context, snapshot_id)
            src_volume_ref = self.db.volume_get(context,
                                                snapshot_ref['volume_id'])
            topic = rpc.queue_get_for(context, FLAGS.volume_topic,
                                      src_volume_ref['host'])
            rpc.cast(
                context, topic, {
                    "method": "create_volume",
                    "args": {
                        "volume_id": volume_id,
                        "snapshot_id": snapshot_id
                    }
                })
        else:
            self.scheduler_rpcapi.create_volume(context, volume_id,
                                                snapshot_id, reservations)
Esempio n. 9
0
    def delete(self, context, volume, force=False):
        volume_id = volume['id']
        if not volume['host']:
            # NOTE(vish): scheduling failed, so delete it
            # Note(zhiteng): update volume quota reservation
            try:
                reservations = QUOTAS.reserve(context, volumes=-1,
                                              gigabytes=-volume['size'])
            except Exception:
                reservations = None
                LOG.exception(_("Failed to update quota for deleting volume."))

            self.db.volume_destroy(context, volume_id)

            if reservations:
                QUOTAS.commit(context, reservations)
            return
        if not force and volume['status'] not in ["available", "error"]:
            msg = _("Volume status must be available or error")
            raise exception.InvalidVolume(reason=msg)

        snapshots = self.db.snapshot_get_all_for_volume(context, volume_id)
        if len(snapshots):
            msg = _("Volume still has %d dependent snapshots") % len(snapshots)
            raise exception.InvalidVolume(reason=msg)

        now = timeutils.utcnow()
        self.db.volume_update(context, volume_id, {'status': 'deleting',
                                                   'terminated_at': now})
        host = volume['host']
        rpc.cast(context,
                 rpc.queue_get_for(context, FLAGS.volume_topic, host),
                 {"method": "delete_volume",
                  "args": {"volume_id": volume_id}})
Esempio n. 10
0
File: api.py Progetto: linets/nova
    def delete(self, context, volume):
        volume_id = volume['id']
        if not volume['host']:
            # NOTE(vish): scheduling failed, so delete it
            self.db.volume_destroy(context, volume_id)
            return
        if volume['status'] not in ["available", "error"]:
            msg = _("Volume status must be available or error")
            raise exception.InvalidVolume(reason=msg)

        snapshots = self.db.snapshot_get_all_for_volume(context, volume_id)
        if len(snapshots):
            msg = _("Volume still has %d dependent snapshots") % len(snapshots)
            raise exception.InvalidVolume(reason=msg)

        now = timeutils.utcnow()
        self.db.volume_update(context, volume_id, {
            'status': 'deleting',
            'terminated_at': now
        })
        host = volume['host']
        rpc.cast(context, rpc.queue_get_for(context, FLAGS.volume_topic, host),
                 {
                     "method": "delete_volume",
                     "args": {
                         "volume_id": volume_id
                     }
                 })
Esempio n. 11
0
        def host_schedule(rpc_method, context, base_options, instance_type,
                          availability_zone, injected_files, admin_password,
                          image, num_instances, requested_networks,
                          block_device_mapping, security_group,
                          filter_properties):

            instance_uuid = base_options.get('uuid')
            now = utils.utcnow()
            self.db.instance_update(context, instance_uuid, {
                'host': target_host,
                'scheduled_at': now
            })

            rpc.cast(
                context,
                rpc.queue_get_for(context, CONF.compute_topic, target_host), {
                    "method": "run_instance",
                    "args": {
                        "instance_uuid": instance_uuid,
                        "availability_zone": availability_zone,
                        "admin_password": admin_password,
                        "injected_files": injected_files,
                        "requested_networks": requested_networks
                    }
                })

            # Instance was already created before calling scheduler
            return self.get(context, instance_uuid)
 def proxy_rpc_to_manager(self, message, host_name, rpc_message, topic, timeout):
     """Proxy RPC to the given compute topic."""
     # Check that the host exists.
     self.db.service_get_by_compute_host(message.ctxt, host_name)
     if message.need_response:
         return rpc.call(message.ctxt, topic, rpc_message, timeout=timeout)
     rpc.cast(message.ctxt, topic, rpc_message)
Esempio n. 13
0
File: api.py Progetto: linets/nova
    def _create_snapshot(self,
                         context,
                         volume,
                         name,
                         description,
                         force=False):
        check_policy(context, 'create_snapshot', volume)

        if ((not force) and (volume['status'] != "available")):
            msg = _("must be available")
            raise exception.InvalidVolume(reason=msg)

        options = {
            'volume_id': volume['id'],
            'user_id': context.user_id,
            'project_id': context.project_id,
            'status': "creating",
            'progress': '0%',
            'volume_size': volume['size'],
            'display_name': name,
            'display_description': description
        }

        snapshot = self.db.snapshot_create(context, options)
        host = volume['host']
        rpc.cast(
            context, rpc.queue_get_for(context, FLAGS.volume_topic, host), {
                "method": "create_snapshot",
                "args": {
                    "volume_id": volume['id'],
                    "snapshot_id": snapshot['id']
                }
            })
        return snapshot
Esempio n. 14
0
 def add_fixed_ip_to_instance(self, context, instance, network_id):
     """Adds a fixed ip to instance from specified network."""
     args = {'instance_id': instance['id'],
             'host': instance['host'],
             'network_id': network_id}
     rpc.cast(context, FLAGS.network_topic,
              {'method': 'add_fixed_ip_to_instance',
               'args': args})
Esempio n. 15
0
File: api.py Progetto: A7Zulu/nova
 def release_floating_ip(self, context, address,
                         affect_auto_assigned=False):
     """Removes floating ip with address from a project. (deallocates)"""
     rpc.cast(context,
              FLAGS.network_topic,
              {'method': 'deallocate_floating_ip',
               'args': {'address': address,
                        'affect_auto_assigned': affect_auto_assigned}})
Esempio n. 16
0
File: api.py Progetto: A7Zulu/nova
 def add_fixed_ip_to_instance(self, context, instance, network_id):
     """Adds a fixed ip to instance from specified network."""
     args = {'instance_id': instance['id'],
             'host': instance['host'],
             'network_id': network_id}
     rpc.cast(context, FLAGS.network_topic,
              {'method': 'add_fixed_ip_to_instance',
               'args': args})
Esempio n. 17
0
 def release_floating_ip(self, context, address,
                         affect_auto_assigned=False):
     """Removes floating ip with address from a project. (deallocates)"""
     rpc.cast(context,
              FLAGS.network_topic,
              {'method': 'deallocate_floating_ip',
               'args': {'address': address,
                        'affect_auto_assigned': affect_auto_assigned}})
Esempio n. 18
0
    def launch_instance(self, context, instance_uuid, params={}):
        pid = context.project_id
        uid = context.user_id

        instance = self.get(context, instance_uuid)
        if not (self._is_instance_blessed(context, instance_uuid)):
            # The instance is not blessed. We can't launch new instances from it.
            raise exception.NovaException(
                _(("Instance %s is not blessed. " +
                   "Please bless the instance before launching from it.") %
                  instance_uuid))

        # Set up security groups to be added - we are passed in names, but need ID's
        security_group_names = params.pop('security_groups', None)
        if security_group_names != None:
            security_groups = [
                self.db.security_group_get_by_name(context, context.project_id,
                                                   sg)
                for sg in security_group_names
            ]
        else:
            security_groups = None

        reservations = self._acquire_addition_reservation(context, instance)
        try:
            # Create a new launched instance.
            new_instance_ref = self._copy_instance(
                context,
                instance_uuid,
                params.get('name',
                           "%s-%s" % (instance['display_name'], "clone")),
                launch=True,
                new_user_data=params.pop('user_data', None),
                security_groups=security_groups)

            LOG.debug(
                _("Casting to scheduler for %(pid)s/%(uid)s's"
                  " instance %(instance_uuid)s") % locals())

            # FIXME: The Folsom scheduler removed support for calling
            # arbitrary functions via the scheduler. Damn. So now we
            # have to make scheduling decisions internally. Until this
            # is sorted, we will simply cast the message and let a random
            # host pick it up. Note that this is simply a stopgap measure.
            rpc.cast(
                context, CONF.gridcentric_topic, {
                    "method": "launch_instance",
                    "args": {
                        "instance_uuid": new_instance_ref['uuid'],
                        "params": params
                    }
                })
            self._commit_reservation(context, reservations)
        except:
            self._rollback_reservation(context, reservations)
            raise

        return self.get(context, new_instance_ref['uuid'])
Esempio n. 19
0
 def deallocate_for_instance(self, context, instance, **kwargs):
     """Deallocates all network structures related to instance."""
     args = kwargs
     args['instance_id'] = instance['id']
     args['project_id'] = instance['project_id']
     args['host'] = instance['host']
     rpc.cast(context, FLAGS.network_topic,
              {'method': 'deallocate_for_instance',
               'args': args})
Esempio n. 20
0
    def remove_fixed_ip_from_instance(self, context, instance, address):
        """Removes a fixed ip from instance from specified network."""

        args = {'instance_id': instance['id'],
                'host': instance['host'],
                'address': address}
        rpc.cast(context, FLAGS.network_topic,
                 {'method': 'remove_fixed_ip_from_instance',
                  'args': args})
Esempio n. 21
0
def cast_to_compute_host(context, host, method, **kwargs):
    """Cast request to a compute host queue"""

    instance_uuid = kwargs.get("instance_uuid", None)
    if instance_uuid:
        instance_update_db(context, instance_uuid, host)

    rpc.cast(context, rpc.queue_get_for(context, "compute", host), {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to compute '%(host)s'") % locals())
Esempio n. 22
0
def cast_to_volume_host(context, host, method, **kwargs):
    """Cast request to a volume host queue"""

    volume_id = kwargs.get("volume_id", None)
    if volume_id is not None:
        now = timeutils.utcnow()
        db.volume_update(context, volume_id, {"host": host, "scheduled_at": now})
    rpc.cast(context, rpc.queue_get_for(context, "volume", host), {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to volume '%(host)s'") % locals())
Esempio n. 23
0
File: api.py Progetto: A7Zulu/nova
    def remove_fixed_ip_from_instance(self, context, instance, address):
        """Removes a fixed ip from instance from specified network."""

        args = {'instance_id': instance['id'],
                'host': instance['host'],
                'address': address}
        rpc.cast(context, FLAGS.network_topic,
                 {'method': 'remove_fixed_ip_from_instance',
                  'args': args})
Esempio n. 24
0
File: api.py Progetto: A7Zulu/nova
 def deallocate_for_instance(self, context, instance, **kwargs):
     """Deallocates all network structures related to instance."""
     args = kwargs
     args['instance_id'] = instance['id']
     args['project_id'] = instance['project_id']
     args['host'] = instance['host']
     rpc.cast(context, FLAGS.network_topic,
              {'method': 'deallocate_for_instance',
               'args': args})
Esempio n. 25
0
def cast_to_compute_host(context, host, method, **kwargs):
    """Cast request to a compute host queue"""

    instance_uuid = kwargs.get('instance_uuid', None)
    if instance_uuid:
        instance_update_db(context, instance_uuid, host)

    rpc.cast(context,
             rpc.queue_get_for(context, 'compute', host),
             {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to compute '%(host)s'") % locals())
Esempio n. 26
0
def cast_to_host(context, topic, host, method, **kwargs):
    """Generic cast to host"""

    topic_mapping = {"compute": cast_to_compute_host, "volume": cast_to_volume_host, "network": cast_to_network_host}

    func = topic_mapping.get(topic)
    if func:
        func(context, host, method, **kwargs)
    else:
        rpc.cast(context, rpc.queue_get_for(context, topic, host), {"method": method, "args": kwargs})
        LOG.debug(_("Casted '%(method)s' to %(topic)s '%(host)s'") % locals())
Esempio n. 27
0
File: api.py Progetto: mattstep/nova
    def create(self, context, size, name, description, snapshot=None,
                     volume_type=None, metadata=None, availability_zone=None):
        check_policy(context, 'create')
        if snapshot is not None:
            if snapshot['status'] != "available":
                msg = _("status must be available")
                raise exception.InvalidSnapshot(reason=msg)
            if not size:
                size = snapshot['volume_size']

            snapshot_id = snapshot['id']
        else:
            snapshot_id = None

        try:
            reservations = QUOTAS.reserve(context, volumes=1, gigabytes=size)
        except exception.OverQuota:
            pid = context.project_id
            LOG.warn(_("Quota exceeded for %(pid)s, tried to create"
                    " %(size)sG volume") % locals())
            raise exception.VolumeSizeTooLarge()

        if availability_zone is None:
            availability_zone = FLAGS.storage_availability_zone

        if volume_type is None:
            volume_type_id = None
        else:
            volume_type_id = volume_type.get('id', None)

        options = {
            'size': size,
            'user_id': context.user_id,
            'project_id': context.project_id,
            'snapshot_id': snapshot_id,
            'availability_zone': availability_zone,
            'status': "creating",
            'attach_status': "detached",
            'display_name': name,
            'display_description': description,
            'volume_type_id': volume_type_id,
            'metadata': metadata,
            }

        volume = self.db.volume_create(context, options)
        rpc.cast(context,
                 FLAGS.scheduler_topic,
                 {"method": "create_volume",
                  "args": {"topic": FLAGS.volume_topic,
                           "volume_id": volume['id'],
                           "snapshot_id": snapshot_id,
                           "reservations": reservations}})
        return volume
Esempio n. 28
0
 def delete_snapshot(self, context, snapshot):
     if snapshot['status'] not in ["available", "error"]:
         msg = _("Volume Snapshot status must be available or error")
         raise exception.InvalidVolume(reason=msg)
     self.db.snapshot_update(context, snapshot['id'],
                             {'status': 'deleting'})
     volume = self.db.volume_get(context, snapshot['volume_id'])
     host = volume['host']
     rpc.cast(context,
              rpc.queue_get_for(context, FLAGS.volume_topic, host),
              {"method": "delete_snapshot",
               "args": {"snapshot_id": snapshot['id']}})
Esempio n. 29
0
def cast_to_compute_host(context, host, method, update_db=True, **kwargs):
    """Cast request to a compute host queue"""

    if update_db:
        # fall back on the id if the uuid is not present
        instance_id = kwargs.get("instance_id", None)
        instance_uuid = kwargs.get("instance_uuid", instance_id)
        if instance_uuid is not None:
            now = timeutils.utcnow()
            db.instance_update(context, instance_uuid, {"host": host, "scheduled_at": now})
    rpc.cast(context, rpc.queue_get_for(context, "compute", host), {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to compute '%(host)s'") % locals())
Esempio n. 30
0
File: api.py Progetto: bhuvan/nova
 def delete_snapshot(self, context, snapshot):
     if snapshot['status'] not in ["available", "error"]:
         msg = _("Volume Snapshot status must be available or error")
         raise exception.InvalidVolume(reason=msg)
     self.db.snapshot_update(context, snapshot['id'],
                             {'status': 'deleting'})
     volume = self.db.volume_get(context, snapshot['volume_id'])
     host = volume['host']
     rpc.cast(context,
              rpc.queue_get_for(context, FLAGS.volume_topic, host),
              {"method": "delete_snapshot",
               "args": {"snapshot_id": snapshot['id']}})
Esempio n. 31
0
def cast_to_volume_host(context, host, method, **kwargs):
    """Cast request to a volume host queue"""

    volume_id = kwargs.get('volume_id', None)
    if volume_id is not None:
        now = timeutils.utcnow()
        db.volume_update(context, volume_id,
                {'host': host, 'scheduled_at': now})
    rpc.cast(context,
             rpc.queue_get_for(context, 'volume', host),
             {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to volume '%(host)s'") % locals())
Esempio n. 32
0
def cast_to_volume_host(context, host, method, update_db=True, **kwargs):
    """Cast request to a volume host queue"""

    if update_db:
        volume_id = kwargs.get('volume_id', None)
        if volume_id is not None:
            now = timeutils.utcnow()
            db.volume_update(context, volume_id,
                    {'host': host, 'scheduled_at': now})
    rpc.cast(context,
             rpc.queue_get_for(context, 'volume', host),
             {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to volume '%(host)s'") % locals())
Esempio n. 33
0
    def cast(self, context, msg, topic=None, version=None):
        """rpc.cast() a remote method.

        :param context: The request context
        :param msg: The message to send, including the method and args.
        :param topic: Override the topic for this message.
        :param version: (Optional) Override the requested API version in this
               message.

        :returns: None.  rpc.cast() does not wait on any return value from the
                  remote method.
        """
        self._set_version(msg, version)
        rpc.cast(context, self._get_topic(topic), msg)
Esempio n. 34
0
    def test_cast_to_network_host(self):
        host = 'fake_host1'
        method = 'fake_method'
        fake_kwargs = {'extra_arg': 'meow'}
        queue = 'fake_queue'

        self.mox.StubOutWithMock(rpc, 'queue_get_for')
        self.mox.StubOutWithMock(rpc, 'cast')

        rpc.queue_get_for(self.context, 'network', host).AndReturn(queue)
        rpc.cast(self.context, queue, {'method': method, 'args': fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_network_host(self.context, host, method, **fake_kwargs)
Esempio n. 35
0
    def test_cast_to_compute_host_update_db_without_instance_uuid(self):
        host = 'fake_host1'
        method = 'fake_method'
        fake_kwargs = {'extra_arg': 'meow'}
        queue = 'fake_queue'

        self.mox.StubOutWithMock(rpc, 'queue_get_for')
        self.mox.StubOutWithMock(rpc, 'cast')

        rpc.queue_get_for(self.context, 'compute', host).AndReturn(queue)
        rpc.cast(self.context, queue, {'method': method, 'args': fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_compute_host(self.context, host, method, **fake_kwargs)
Esempio n. 36
0
    def test_cast_to_network_host(self):
        host = "fake_host1"
        method = "fake_method"
        fake_kwargs = {"extra_arg": "meow"}
        queue = "fake_queue"

        self.mox.StubOutWithMock(rpc, "queue_get_for")
        self.mox.StubOutWithMock(rpc, "cast")

        rpc.queue_get_for(self.context, "network", host).AndReturn(queue)
        rpc.cast(self.context, queue, {"method": method, "args": fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_network_host(self.context, host, method, **fake_kwargs)
Esempio n. 37
0
def cast_to_host(context, topic, host, method, **kwargs):
    """Generic cast to host"""

    topic_mapping = {CONF.compute_topic: cast_to_compute_host}

    func = topic_mapping.get(topic)
    if func:
        cast_to_compute_host(context, host, method, **kwargs)
    else:
        rpc.cast(context,
                 rpc.queue_get_for(context, topic, host),
                 {"method": method, "args": kwargs})
        LOG.debug(_("Casted '%(method)s' to %(topic)s '%(host)s'")
                % locals())
Esempio n. 38
0
    def test_cast_to_compute_host_update_db_without_instance_uuid(self):
        host = "fake_host1"
        method = "fake_method"
        fake_kwargs = {"extra_arg": "meow"}
        queue = "fake_queue"

        self.mox.StubOutWithMock(rpc, "queue_get_for")
        self.mox.StubOutWithMock(rpc, "cast")

        rpc.queue_get_for(self.context, "compute", host).AndReturn(queue)
        rpc.cast(self.context, queue, {"method": method, "args": fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_compute_host(self.context, host, method, **fake_kwargs)
Esempio n. 39
0
    def cast(self, context, msg, topic=None, version=None):
        """rpc.cast() a remote method.

        :param context: The request context
        :param msg: The message to send, including the method and args.
        :param topic: Override the topic for this message.
        :param version: (Optional) Override the requested API version in this
               message.

        :returns: None.  rpc.cast() does not wait on any return value from the
                  remote method.
        """
        self._set_version(msg, version)
        rpc.cast(context, self._get_topic(topic), msg)
Esempio n. 40
0
def cast_to_compute_host(context, host, method, update_db=True, **kwargs):
    """Cast request to a compute host queue"""

    if update_db:
        # fall back on the id if the uuid is not present
        instance_id = kwargs.get('instance_id', None)
        instance_uuid = kwargs.get('instance_uuid', instance_id)
        if instance_uuid is not None:
            now = timeutils.utcnow()
            db.instance_update(context, instance_uuid,
                    {'host': host, 'scheduled_at': now})
    rpc.cast(context,
             rpc.queue_get_for(context, 'compute', host),
             {"method": method, "args": kwargs})
    LOG.debug(_("Casted '%(method)s' to compute '%(host)s'") % locals())
Esempio n. 41
0
    def launch_instance(self, context, instance_uuid, params={}):
        pid = context.project_id
        uid = context.user_id

        instance = self.get(context, instance_uuid)
        if not(self._is_instance_blessed(context, instance_uuid)):
            # The instance is not blessed. We can't launch new instances from it.
            raise exception.NovaException(
                  _(("Instance %s is not blessed. " +
                     "Please bless the instance before launching from it.") % instance_uuid))

        # Set up security groups to be added - we are passed in names, but need ID's
        security_group_names = params.pop('security_groups', None)
        if security_group_names != None:
            security_groups = [self.db.security_group_get_by_name(context,
                context.project_id, sg) for sg in security_group_names]
        else:
            security_groups = None

        reservations = self._acquire_addition_reservation(context, instance)
        try:
            # Create a new launched instance.
            new_instance_ref = self._copy_instance(context, instance_uuid,
                params.get('name', "%s-%s" % (instance['display_name'], "clone")),
                launch=True, new_user_data=params.pop('user_data', None),
                security_groups=security_groups)


            LOG.debug(_("Casting to scheduler for %(pid)s/%(uid)s's"
                        " instance %(instance_uuid)s") % locals())

            # FIXME: The Folsom scheduler removed support for calling
            # arbitrary functions via the scheduler. Damn. So now we
            # have to make scheduling decisions internally. Until this
            # is sorted, we will simply cast the message and let a random
            # host pick it up. Note that this is simply a stopgap measure.
            rpc.cast(context,
                         CONF.gridcentric_topic,
                         {"method": "launch_instance",
                          "args": {"instance_uuid": new_instance_ref['uuid'],
                                   "params": params}})
            self._commit_reservation(context, reservations)
        except:
            self._rollback_reservation(context, reservations)
            raise

        return self.get(context, new_instance_ref['uuid'])
Esempio n. 42
0
    def test_cast_to_compute_host_update_db_without_instance_uuid(self):
        host = 'fake_host1'
        method = 'fake_method'
        fake_kwargs = {'extra_arg': 'meow'}
        queue = 'fake_queue'

        self.mox.StubOutWithMock(rpc, 'queue_get_for')
        self.mox.StubOutWithMock(rpc, 'cast')

        rpc.queue_get_for(self.context, 'compute', host).AndReturn(queue)
        rpc.cast(self.context, queue,
                {'method': method,
                 'args': fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_compute_host(self.context, host, method,
                **fake_kwargs)
Esempio n. 43
0
def cast_to_host(context, topic, host, method, update_db=True, **kwargs):
    """Generic cast to host"""

    topic_mapping = {
            "compute": cast_to_compute_host,
            "volume": cast_to_volume_host,
            'network': cast_to_network_host}

    func = topic_mapping.get(topic)
    if func:
        func(context, host, method, update_db=update_db, **kwargs)
    else:
        rpc.cast(context,
                 rpc.queue_get_for(context, topic, host),
                 {"method": method, "args": kwargs})
        LOG.debug(_("Casted '%(method)s' to %(topic)s '%(host)s'")
                % locals())
Esempio n. 44
0
    def test_cast_to_network_host(self):
        host = 'fake_host1'
        method = 'fake_method'
        fake_kwargs = {'extra_arg': 'meow'}
        queue = 'fake_queue'

        self.mox.StubOutWithMock(rpc, 'queue_get_for')
        self.mox.StubOutWithMock(rpc, 'cast')

        rpc.queue_get_for(self.context, 'network', host).AndReturn(queue)
        rpc.cast(self.context, queue,
                {'method': method,
                 'args': fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_network_host(self.context, host, method,
                **fake_kwargs)
Esempio n. 45
0
def forward_request(context, request_type, master, aggregate_id,
                    slave_compute, slave_address, slave_uuid):
    """Casts add/remove requests to the pool master."""
    # replace the address from the xenapi connection url
    # because this might be 169.254.0.1, i.e. xenapi
    # NOTE: password in clear is not great, but it'll do for now
    sender_url = swap_xapi_host(FLAGS.xenapi_connection_url, slave_address)
    rpc.cast(context, rpc.queue_get_for(context, FLAGS.compute_topic, master),
             {"method": request_type,
              "args": {"aggregate_id": aggregate_id,
                       "host": slave_compute,
                       "url": sender_url,
                       "user": FLAGS.xenapi_connection_username,
                       "passwd": FLAGS.xenapi_connection_password,
                       "compute_uuid": vm_utils.get_this_vm_uuid(),
                       "xenhost_uuid": slave_uuid, },
             })
Esempio n. 46
0
    def test_cast_to_compute_host_update_db_with_instance_uuid(self):
        host = "fake_host1"
        method = "fake_method"
        fake_kwargs = {"instance_uuid": "fake_uuid", "extra_arg": "meow"}
        queue = "fake_queue"

        self.mox.StubOutWithMock(timeutils, "utcnow")
        self.mox.StubOutWithMock(db, "instance_update")
        self.mox.StubOutWithMock(rpc, "queue_get_for")
        self.mox.StubOutWithMock(rpc, "cast")

        timeutils.utcnow().AndReturn("fake-now")
        db.instance_update(self.context, "fake_uuid", {"host": None, "scheduled_at": "fake-now"})
        rpc.queue_get_for(self.context, "compute", host).AndReturn(queue)
        rpc.cast(self.context, queue, {"method": method, "args": fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_compute_host(self.context, host, method, **fake_kwargs)
Esempio n. 47
0
    def test_cast_to_host_unknown_topic(self):
        host = 'fake_host1'
        method = 'fake_method'
        fake_kwargs = {'extra_arg': 'meow'}
        topic = 'unknown'
        queue = 'fake_queue'

        self.mox.StubOutWithMock(rpc, 'queue_get_for')
        self.mox.StubOutWithMock(rpc, 'cast')

        rpc.queue_get_for(self.context, topic, host).AndReturn(queue)
        rpc.cast(self.context, queue,
                {'method': method,
                 'args': fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_host(self.context, topic, host, method,
                update_db=False, **fake_kwargs)
Esempio n. 48
0
    def test_cast_to_host_unknown_topic(self):
        host = 'fake_host1'
        method = 'fake_method'
        fake_kwargs = {'extra_arg': 'meow'}
        topic = 'unknown'
        queue = 'fake_queue'

        self.mox.StubOutWithMock(rpc, 'queue_get_for')
        self.mox.StubOutWithMock(rpc, 'cast')

        rpc.queue_get_for(self.context, topic, host).AndReturn(queue)
        rpc.cast(self.context, queue,
                {'method': method,
                 'args': fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_host(self.context, topic, host, method,
                update_db=False, **fake_kwargs)
Esempio n. 49
0
def forward_request(context, request_type, master, aggregate_id, slave_compute,
                    slave_address, slave_uuid):
    """Casts add/remove requests to the pool master."""
    # replace the address from the xenapi connection url
    # because this might be 169.254.0.1, i.e. xenapi
    # NOTE: password in clear is not great, but it'll do for now
    sender_url = swap_xapi_host(FLAGS.xenapi_connection_url, slave_address)
    rpc.cast(
        context, rpc.queue_get_for(context, FLAGS.compute_topic, master), {
            "method": request_type,
            "args": {
                "aggregate_id": aggregate_id,
                "host": slave_compute,
                "url": sender_url,
                "user": FLAGS.xenapi_connection_username,
                "passwd": FLAGS.xenapi_connection_password,
                "compute_uuid": vm_utils.get_this_vm_uuid(),
                "xenhost_uuid": slave_uuid,
            },
        })
    def test_proxy_rpc_to_manager_cast(self):
        fake_topic = 'fake-topic'
        fake_rpc_message = 'fake-rpc-message'
        fake_host_name = 'fake-host-name'

        self.mox.StubOutWithMock(self.tgt_db_inst,
                                 'service_get_by_compute_host')
        self.mox.StubOutWithMock(rpc, 'cast')

        self.tgt_db_inst.service_get_by_compute_host(self.ctxt,
                                                     fake_host_name)
        rpc.cast(self.ctxt, fake_topic, fake_rpc_message)

        self.mox.ReplayAll()

        self.src_msg_runner.proxy_rpc_to_manager(
                self.ctxt,
                self.tgt_cell_name,
                fake_host_name,
                fake_topic,
                fake_rpc_message, False, timeout=None)
Esempio n. 51
0
    def test_cast_to_compute_host_update_db_with_instance_uuid(self):
        host = 'fake_host1'
        method = 'fake_method'
        fake_kwargs = {'instance_uuid': 'fake_uuid', 'extra_arg': 'meow'}
        queue = 'fake_queue'

        self.mox.StubOutWithMock(timeutils, 'utcnow')
        self.mox.StubOutWithMock(db, 'instance_update')
        self.mox.StubOutWithMock(rpc, 'queue_get_for')
        self.mox.StubOutWithMock(rpc, 'cast')

        timeutils.utcnow().AndReturn('fake-now')
        db.instance_update(self.context, 'fake_uuid', {
            'host': None,
            'scheduled_at': 'fake-now'
        })
        rpc.queue_get_for(self.context, 'compute', host).AndReturn(queue)
        rpc.cast(self.context, queue, {'method': method, 'args': fake_kwargs})

        self.mox.ReplayAll()
        driver.cast_to_compute_host(self.context, host, method, **fake_kwargs)
Esempio n. 52
0
    def _cast_gridcentric_message(self, method, context, instance_uuid, host=None, params=None):
        """Generic handler for RPC casts to gridcentric. This does not block for a response.

        :param params: Optional dictionary of arguments to be passed to the
                       gridcentric worker

        :returns: None
        """

        if not params:
            params = {}
        if not host:
            instance = self.get(context, instance_uuid)
            host = instance["host"]
        if not host:
            queue = FLAGS.gridcentric_topic
        else:
            queue = self.db.queue_get_for(context, FLAGS.gridcentric_topic, host)
        params["instance_uuid"] = instance_uuid
        kwargs = {"method": method, "args": params}
        rpc.cast(context, queue, kwargs)
Esempio n. 53
0
    def install_policy(self, context, policy_ini_string, wait):
        validated = False
        faults = []
        for host in self._list_cobalt_hosts(context):
            queue = rpc.queue_get_for(context, CONF.cobalt_topic, host)
            args = {
                "method": "install_policy",
                "args": {
                    "policy_ini_string": policy_ini_string
                },
            }

            if (not validated) or wait:
                try:
                    rpc.call(context, queue, args)
                    validated = True
                except Exception, ex:
                    faults.append((host, str(ex)))
                    if not wait:
                        raise exception.NovaException(
                            _("Failed to install policy on host %s: %s" % \
                                (host, str(ex))))
            else:
                rpc.cast(context, queue, args)
Esempio n. 54
0
    def create(self,
               context,
               size,
               name,
               description,
               snapshot=None,
               volume_type=None,
               metadata=None,
               availability_zone=None):
        check_policy(context, 'create')
        if snapshot is not None:
            if snapshot['status'] != "available":
                msg = _("status must be available")
                raise exception.InvalidSnapshot(reason=msg)
            if not size:
                size = snapshot['volume_size']

            snapshot_id = snapshot['id']
        else:
            snapshot_id = None

        if not isinstance(size, int) or size <= 0:
            msg = _('Volume size must be an integer and greater than 0')
            raise exception.InvalidInput(reason=msg)
        try:
            reservations = QUOTAS.reserve(context, volumes=1, gigabytes=size)
        except exception.OverQuota as e:
            overs = e.kwargs['overs']
            usages = e.kwargs['usages']
            quotas = e.kwargs['quotas']

            def _consumed(name):
                return (usages[name]['reserved'] + usages[name]['in_use'])

            pid = context.project_id
            if 'gigabytes' in overs:
                consumed = _consumed('gigabytes')
                quota = quotas['gigabytes']
                LOG.warn(
                    _("Quota exceeded for %(pid)s, tried to create "
                      "%(size)sG volume (%(consumed)dG of %(quota)dG "
                      "already consumed)") % locals())
                raise exception.VolumeSizeTooLarge()
            elif 'volumes' in overs:
                consumed = _consumed('volumes')
                LOG.warn(
                    _("Quota exceeded for %(pid)s, tried to create "
                      "volume (%(consumed)d volumes already consumed)") %
                    locals())
                raise exception.VolumeLimitExceeded(allowed=quotas['volumes'])

        if availability_zone is None:
            availability_zone = FLAGS.storage_availability_zone

        if volume_type is None:
            volume_type_id = None
        else:
            volume_type_id = volume_type.get('id', None)

        options = {
            'size': size,
            'user_id': context.user_id,
            'project_id': context.project_id,
            'snapshot_id': snapshot_id,
            'availability_zone': availability_zone,
            'status': "creating",
            'attach_status': "detached",
            'display_name': name,
            'display_description': description,
            'volume_type_id': volume_type_id,
            'metadata': metadata,
        }

        volume = self.db.volume_create(context, options)
        rpc.cast(
            context, FLAGS.scheduler_topic, {
                "method": "create_volume",
                "args": {
                    "topic": FLAGS.volume_topic,
                    "volume_id": volume['id'],
                    "snapshot_id": snapshot_id,
                    "reservations": reservations
                }
            })
        return volume
Esempio n. 55
0
 def add_network_to_project(self, context, project_id):
     """Force adds another network to a project."""
     rpc.cast(context, FLAGS.network_topic,
              {'method': 'add_network_to_project',
               'args': {'project_id': project_id}})