def update_metadata(self, context, updates):
     payload = {'aggregate_id': self.id,
                'meta_data': updates}
     compute_utils.notify_about_aggregate_update(context,
                                                 "updatemetadata.start",
                                                 payload)
     to_add = {}
     for key, value in updates.items():
         if value is None:
             try:
                 db.aggregate_metadata_delete(context, self.id, key)
             except exception.AggregateMetadataNotFound:
                 pass
             try:
                 self.metadata.pop(key)
             except KeyError:
                 pass
         else:
             to_add[key] = value
             self.metadata[key] = value
     db.aggregate_metadata_add(context, self.id, to_add)
     compute_utils.notify_about_aggregate_update(context,
                                                 "updatemetadata.end",
                                                 payload)
     self.obj_reset_changes(fields=['metadata'])

 def test_aggregate_metadata_delete(self):
     aggregate = {'name': 'fake aggregate', 'id': 'fake-id'}
     self.mox.StubOutWithMock(db, 'aggregate_metadata_delete')
     db.aggregate_metadata_delete(mox.IgnoreArg(), aggregate['id'], 'fake')
     self.mox.ReplayAll()
     result = self.conductor.aggregate_metadata_delete(self.context,
                                                    aggregate,
                                                    'fake')

 def test_aggregate_metadata_delete(self):
     """Ensure we can delete metadata for the aggregate."""
     ctxt = context.get_admin_context()
     result = _create_aggregate(context=ctxt, metadata=None)
     metadata = _get_fake_aggr_metadata()
     db.aggregate_metadata_add(ctxt, result.id, metadata)
     db.aggregate_metadata_delete(ctxt, result.id, metadata.keys()[0])
     expected = db.aggregate_metadata_get(ctxt, result.id)
     del metadata[metadata.keys()[0]]
     self.assertDictMatch(metadata, expected)

    def remove_from_aggregate(self, context, aggregate, host, slave_info=None):
        """Remove a compute host from an aggregate."""
        slave_info = slave_info or dict()
        if not self._is_hv_pool(context, aggregate.id):
            return

        invalid = {pool_states.CREATED: 'no hosts to remove',
                   pool_states.CHANGING: 'setup in progress',
                   pool_states.DISMISSED: 'aggregate deleted', }
        if (self._get_metadata(context, aggregate.id)[pool_states.KEY]
                in invalid.keys()):
            raise exception.InvalidAggregateAction(
                    action='remove host',
                    aggregate_id=aggregate.id,
                    reason=invalid[self._get_metadata(context,
                            aggregate.id)[pool_states.KEY]])

        master_compute = self._get_metadata(context,
                aggregate.id)['master_compute']
        if master_compute == FLAGS.host and master_compute != host:
            # this is the master -> instruct it to eject a host from the pool
            host_uuid = self._get_metadata(context, aggregate.id)[host]
            self._eject_slave(aggregate.id,
                              slave_info.get('compute_uuid'), host_uuid)
            db.aggregate_metadata_delete(context, aggregate.id, host)
        elif master_compute == host:
            # Remove master from its own pool -> destroy pool only if the
            # master is on its own, otherwise raise fault. Destroying a
            # pool made only by master is fictional
            if len(aggregate.hosts) > 1:
                # NOTE: this could be avoided by doing a master
                # re-election, but this is simpler for now.
                raise exception.InvalidAggregateAction(
                                    aggregate_id=aggregate.id,
                                    action='remove_from_aggregate',
                                    reason=_('Unable to eject %(host)s '
                                             'from the pool; pool not empty')
                                             % locals())
            self._clear_pool(aggregate.id)
            for key in ['master_compute', host]:
                db.aggregate_metadata_delete(context, aggregate.id, key)
        elif master_compute and master_compute != host:
            # A master exists -> forward pool-eject request to master
            slave_info = self._create_slave_info()

            self.compute_rpcapi.remove_aggregate_host(
                context, aggregate.id, host, master_compute, slave_info)
        else:
            # this shouldn't have happened
            raise exception.AggregateError(aggregate_id=aggregate.id,
                                           action='remove_from_aggregate',
                                           reason=_('Unable to eject %(host)s '
                                           'from the pool; No master found')
                                           % locals())

 def test_aggregate_metadata_update(self):
     """Ensure we can update metadata for the aggregate."""
     ctxt = context.get_admin_context()
     result = _create_aggregate(context=ctxt)
     metadata = _get_fake_aggr_metadata()
     key = metadata.keys()[0]
     db.aggregate_metadata_delete(ctxt, result.id, key)
     new_metadata = {key: 'foo'}
     db.aggregate_metadata_add(ctxt, result.id, new_metadata)
     expected = db.aggregate_metadata_get(ctxt, result.id)
     metadata[key] = 'foo'
     self.assertDictMatch(metadata, expected)

 def test_update_metadata(self):
     self.mox.StubOutWithMock(db, 'aggregate_metadata_delete')
     self.mox.StubOutWithMock(db, 'aggregate_metadata_add')
     db.aggregate_metadata_delete(self.context, 123, 'todelete')
     db.aggregate_metadata_add(self.context, 123, {'toadd': 'myval'})
     self.mox.ReplayAll()
     agg = aggregate.Aggregate()
     agg._context = self.context
     agg.id = 123
     agg.metadata = {'foo': 'bar'}
     agg.obj_reset_changes()
     agg.update_metadata({'todelete': None, 'toadd': 'myval'})
     self.assertEqual({'foo': 'bar', 'toadd': 'myval'}, agg.metadata)

 def test_aggregate_metdata_get_by_host_with_key(self):
     """Ensure we can get aggregates by host."""
     ctxt = context.get_admin_context()
     values = {"name": "fake_aggregate2", "availability_zone": "fake_avail_zone"}
     values2 = {"name": "fake_aggregate3", "availability_zone": "fake_avail_zone"}
     a1 = _create_aggregate_with_hosts(context=ctxt)
     a2 = _create_aggregate_with_hosts(context=ctxt, values=values)
     a3 = _create_aggregate_with_hosts(
         context=ctxt, values=values2, hosts=["foo.openstack.org"], metadata={"good": "value"}
     )
     r1 = db.aggregate_metadata_get_by_host(ctxt, "foo.openstack.org", key="good")
     self.assertEqual(r1["good"], set(["value"]))
     self.assertFalse("fake_key1" in r1)
     # Delete metadata
     db.aggregate_metadata_delete(ctxt, a3.id, "good")
     r2 = db.aggregate_metadata_get_by_host(ctxt, "foo.openstack.org", key="good")
     self.assertFalse("good" in r2)

 def test_aggregate_metdata_get_by_host_with_key(self):
     """Ensure we can get aggregates by host."""
     ctxt = context.get_admin_context()
     values = {'name': 'fake_aggregate2',
         'availability_zone': 'fake_avail_zone', }
     values2 = {'name': 'fake_aggregate3',
         'availability_zone': 'fake_avail_zone', }
     a1 = _create_aggregate_with_hosts(context=ctxt)
     a2 = _create_aggregate_with_hosts(context=ctxt, values=values)
     a3 = _create_aggregate_with_hosts(context=ctxt, values=values2,
             hosts=['foo.openstack.org'], metadata={'good': 'value'})
     r1 = db.aggregate_metadata_get_by_host(ctxt, 'foo.openstack.org',
                                            key='good')
     self.assertEqual(r1['good'], set(['value']))
     self.assertFalse('fake_key1' in r1)
     # Delete metadata
     db.aggregate_metadata_delete(ctxt, a3.id, 'good')
     r2 = db.aggregate_metadata_get_by_host(ctxt, 'foo.openstack.org',
                                            key='good')
     self.assertFalse('good' in r2)

 def test_update_metadata(self):
     self.mox.StubOutWithMock(db, "aggregate_metadata_delete")
     self.mox.StubOutWithMock(db, "aggregate_metadata_add")
     db.aggregate_metadata_delete(self.context, 123, "todelete")
     db.aggregate_metadata_add(self.context, 123, {"toadd": "myval"})
     self.mox.ReplayAll()
     fake_notifier.NOTIFICATIONS = []
     agg = aggregate.Aggregate()
     agg._context = self.context
     agg.id = 123
     agg.metadata = {"foo": "bar"}
     agg.obj_reset_changes()
     agg.update_metadata({"todelete": None, "toadd": "myval"})
     self.assertEqual(2, len(fake_notifier.NOTIFICATIONS))
     msg = fake_notifier.NOTIFICATIONS[0]
     self.assertEqual("aggregate.updatemetadata.start", msg.event_type)
     self.assertEqual({"todelete": None, "toadd": "myval"}, msg.payload["meta_data"])
     msg = fake_notifier.NOTIFICATIONS[1]
     self.assertEqual("aggregate.updatemetadata.end", msg.event_type)
     self.assertEqual({"todelete": None, "toadd": "myval"}, msg.payload["meta_data"])
     self.assertEqual({"foo": "bar", "toadd": "myval"}, agg.metadata)

 def test_update_metadata(self):
     self.mox.StubOutWithMock(db, 'aggregate_metadata_delete')
     self.mox.StubOutWithMock(db, 'aggregate_metadata_add')
     db.aggregate_metadata_delete(self.context, 123, 'todelete')
     db.aggregate_metadata_add(self.context, 123, {'toadd': 'myval'})
     self.mox.ReplayAll()
     fake_notifier.NOTIFICATIONS = []
     agg = aggregate.Aggregate()
     agg._context = self.context
     agg.id = 123
     agg.metadata = {'foo': 'bar'}
     agg.obj_reset_changes()
     agg.update_metadata({'todelete': None, 'toadd': 'myval'})
     self.assertEqual(2, len(fake_notifier.NOTIFICATIONS))
     msg = fake_notifier.NOTIFICATIONS[0]
     self.assertEqual('aggregate.updatemetadata.start', msg.event_type)
     self.assertEqual({'todelete': None, 'toadd': 'myval'},
                      msg.payload['meta_data'])
     msg = fake_notifier.NOTIFICATIONS[1]
     self.assertEqual('aggregate.updatemetadata.end', msg.event_type)
     self.assertEqual({'todelete': None, 'toadd': 'myval'},
                      msg.payload['meta_data'])
     self.assertEqual({'foo': 'bar', 'toadd': 'myval'}, agg.metadata)

 def remove_from_aggregate(self, context, aggregate, host, **kwargs):
     """Remove a compute host from an aggregate."""
     master_compute = aggregate.metadetails.get('master_compute')
     if master_compute == FLAGS.host and master_compute != host:
         # this is the master -> instruct it to eject a host from the pool
         host_uuid = db.aggregate_metadata_get(context, aggregate.id)[host]
         self._eject_slave(aggregate.id,
                           kwargs.get('compute_uuid'), host_uuid)
         db.aggregate_metadata_delete(context, aggregate.id, host)
     elif master_compute == host:
         # Remove master from its own pool -> destroy pool only if the
         # master is on its own, otherwise raise fault. Destroying a
         # pool made only by master is fictional
         if len(aggregate.hosts) > 1:
             # NOTE: this could be avoided by doing a master
             # re-election, but this is simpler for now.
             raise exception.InvalidAggregateAction(
                                 aggregate_id=aggregate.id,
                                 action='remove_from_aggregate',
                                 reason=_('Unable to eject %(host)s '
                                          'from the pool; pool not empty')
                                          % locals())
         self._clear_pool(aggregate.id)
         for key in ['master_compute', host]:
             db.aggregate_metadata_delete(context, aggregate.id, key)
     elif master_compute and master_compute != host:
         # A master exists -> forward pool-eject request to master
         forward_request(context, "remove_aggregate_host", master_compute,
                         aggregate.id, host,
                         self._host_addr, self._host_uuid)
     else:
         # this shouldn't have happened
         raise exception.AggregateError(aggregate_id=aggregate.id,
                                        action='remove_from_aggregate',
                                        reason=_('Unable to eject %(host)s '
                                        'from the pool; No master found')
                                        % locals())

 def test_aggregate_metadata_delete(self):
     aggregate = {"name": "fake aggregate", "id": "fake-id"}
     self.mox.StubOutWithMock(db, "aggregate_metadata_delete")
     db.aggregate_metadata_delete(mox.IgnoreArg(), aggregate["id"], "fake")
     self.mox.ReplayAll()
     result = self.conductor.aggregate_metadata_delete(self.context, aggregate, "fake")

 def aggregate_metadata_delete(self, context, aggregate_id, key):
     return db.aggregate_metadata_delete(context, aggregate_id, key)