def chassis_create_update(self, event_type, payload, timestamp):
LOG.debug("Updating chassis information for %s", payload['uuid'])
chassis = serialize_resource(payload, resources.CHASSIS_FIELDS)
version = self.get_version(chassis, timestamp)
self.index_helper.save_document(chassis, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, chassis)
def node_create_update(self, event_type, payload, timestamp):
LOG.debug("Updating node information for %s", payload['uuid'])
node = serialize_resource(payload, resources.NODE_FIELDS)
version = self.get_version(node, timestamp)
self.index_helper.save_document(node, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, node)
def port_create_update(self, event_type, payload, timestamp):
LOG.debug("Updating port information for %s", payload['uuid'])
port = serialize_resource(payload, resources.PORT_FIELDS)
version = self.get_version(port, timestamp)
self.index_helper.save_document(port, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, port)
def create_or_update_recordset(self, event_type, payload, timestamp):
rs_payload = self._serialize(payload)
self.index_helper.save_document(rs_payload,
version=self.get_version(
rs_payload, timestamp))
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, rs_payload)
def create_ns(self, event_type, payload, timestamp):
namespace = self.format_namespace(payload)
self.index_helper.save_document(namespace,
version=self.get_version(
namespace, timestamp))
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, namespace)
def delete_instance(self, event_type, payload, timestamp):
# When an instance is deleted from Nova, its' record in
# InstanceGroup DB was cleaned directly from DB layer in
# Nova, we should perform sync to keep Searchlight
# up-to-date with Nova DB.
instance_id = payload['instance_id']
query = {'filter': {'term': {'members': instance_id}}}
search_results = self.index_helper.simple_search(
query=query, type="OS::Nova::ServerGroup")
server_group = None
try:
result = search_results['hits'][0]
server_group_id = result['_id']
server_group = self._update_server_group_members(server_group_id,
instance_id,
delete=True)
except IndexError:
LOG.debug("No nova server group information for instance %s",
instance_id)
if server_group:
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, server_group)
def addmember(self, event_type, payload, timestamp):
server_group_id = payload['server_group_id']
instance_id = payload['instance_uuids'][0]
server_group = self._update_server_group_members(
server_group_id, instance_id)
if server_group:
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, server_group)
def create_or_update(self, event_type, payload, timestamp):
flavor = serialize_nova_flavor(payload['nova_object.data'])
version = self.get_version(flavor, timestamp)
LOG.debug("Updating nova flavor information for %s", flavor['id'])
self.index_helper.save_document(flavor, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, flavor)
def delete_field(self, event_type, payload, timestamp, field):
id = payload['namespace']
preexisting = self.index_helper.get_document(id, for_admin=True)
preexisting['_source'].pop(field, None)
self.index_helper.save_document(preexisting['_source'],
preexisting['_version'] + 1)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, preexisting['_source'])
def node_update(self, event_type, payload, timestamp):
node_id = payload['uuid']
LOG.debug("Updating node information for %s", node_id)
node = serialize_resource(payload, resources.NODE_FIELDS)
self.index_helper.update_document(node,
node_id,
update_as_script=False)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, node)
def create_obj(self, event_type, payload, timestamp):
id = payload['namespace']
object = self.format_object(payload)
preexisting = self.index_helper.get_document(id, for_admin=True)
self.create_entity(preexisting['_source'], 'objects', object)
self.index_helper.save_document(preexisting['_source'],
preexisting['_version'] + 1)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, preexisting['_source'])
def create_or_update(self, event_type, payload, timestamp):
subnet_id = payload['subnet']['id']
LOG.debug("Updating subnet information for %s", subnet_id)
subnet = serialize_subnet(payload['subnet'])
version = self.get_version(subnet, timestamp)
self.index_helper.save_document(subnet, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, subnet)
def delete_tag(self, event_type, payload, timestamp):
id = payload['namespace']
preexisting = self.index_helper.get_document(id, for_admin=True)
self.delete_entity(preexisting['_source'], "tags", payload['name'],
"name")
self.index_helper.save_document(preexisting['_source'],
preexisting['_version'] + 1)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, preexisting['_source'])
def update_prop(self, event_type, payload, timestamp):
id = payload['namespace']
property = self.format_property(payload)
preexisting = self.index_helper.get_document(id, for_admin=True)
self.update_entity(preexisting['_source'], "properties",
payload['name_old'], property, "name")
self.index_helper.save_document(preexisting['_source'],
preexisting['_version'] + 1)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, preexisting['_source'])
def sync_members(self, event_type, payload, timestamp):
image_id = payload['image_id']
image_es = self.index_helper.get_document(image_id, for_admin=True)
image_payload = serialize_glance_image_members(image_es['_source'],
payload)
self.index_helper.save_document(image_payload)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, image_payload)
def create_or_update(self, event_type, payload, timestamp):
fip_id = payload['floatingip']['id']
LOG.debug("Updating floatingip information for %s", fip_id)
floatingip = serialize_floatingip(
payload['floatingip'],
updated_at=utils.timestamp_to_isotime(timestamp))
version = self.get_version(floatingip, timestamp)
self.index_helper.save_document(floatingip, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, floatingip)
def create_or_update(self, event_type, payload, timestamp):
router_id = payload['router']['id']
LOG.debug("Updating router information for %s", router_id)
router = serialize_router(
payload['router'],
updated_at=utils.timestamp_to_isotime(timestamp))
version = self.get_version(router, timestamp)
self.index_helper.save_document(router, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, router)
def create_or_update(self, event_type, payload, timestamp):
network_id = payload['network']['id']
LOG.debug("Updating network information for %s", network_id)
# Neutron doesn't give us any date/time information
network = serialize_network(payload['network'])
version = self.get_version(network, timestamp)
self.index_helper.save_document(network, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, network)
def create_or_update(self, event_type, payload, timestamp):
snapshot_id = payload['snapshot_id']
LOG.debug("Updating cinder snapshot information for %s", snapshot_id)
try:
snapshot_payload = serialize_cinder_snapshot(snapshot_id)
version = self.get_version(snapshot_payload, timestamp)
self.index_helper.save_document(snapshot_payload, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, snapshot_payload)
except cinderclient.exceptions.NotFound:
LOG.warning(_LW("Snapshot %s not found; deleting") % snapshot_id)
self.delete(payload, timestamp)
def create_or_update(self, event_type, payload, timestamp):
image_id = payload['id']
try:
image_payload = self.serialize_notification(payload)
self.index_helper.save_document(image_payload,
version=self.get_version(
image_payload, timestamp))
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, image_payload)
except glanceclient.exc.NotFound:
LOG.warning(_LW("Image %s not found; deleting") % image_id)
return self.delete(event_type, payload, timestamp)
def _partial_state_update(
self, event_type, payload, update_if_state_matches):
"""Issue a partial document update that will only affect
state and task_state fields.
"""
instance_id = payload['instance_id']
LOG.debug("Attempting partial state update for %s matching %s",
instance_id, update_if_state_matches)
state_field_values = {
self._state_fields[k]: payload[k]
for k in self._state_fields if k in payload
}
if state_field_values:
# Don't want to use groovy scripting
# because there's a high chance it'll be disabled; instead, will
# get 'n' retrieve ourselves
preexisting = self.index_helper.get_document(instance_id,
for_admin=True)
def should_update(_source):
for key, value in update_if_state_matches.items():
key = self._state_fields[key]
if key not in _source:
LOG.debug("Skipping state update for %s; precondition "
"'%s' not in existing source",
instance_id, key)
return False
if _source[key] != value:
LOG.debug(
"Skipping state update for %s; precondition "
"'%s' = '%s' doesn't match '%s' in source",
instance_id, key, value, _source[key])
return False
return True
if preexisting:
if should_update(preexisting['_source']):
LOG.debug("Performing state update for %s", instance_id)
# All preconditions matched; save_document will attempt
# to save merged document
# TODO(sjmc7) - use the existing update_at to generate
# a new timestamp? Still seems kind of made up
preexisting['_source'].update(state_field_values)
self.index_helper.save_document(
preexisting['_source'],
version=preexisting['_version'] + 1
)
return pipeline.IndexItem(self.index_helper.plugin,
event_type,
payload,
preexisting['_source'])
def update_ns(self, event_type, payload, timestamp):
# Update operation in es doesn't support external version,
# so we have to manually update the doc and reindex it.
namespace_es = self.index_helper.get_document(payload['namespace_old'],
for_admin=True)
namespace = self.format_namespace(payload)
namespace_es['_source'].update(namespace)
self.index_helper.save_document(namespace_es['_source'],
version=self.get_version(
namespace, timestamp))
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, namespace_es['_source'])
def create_or_update(self, event_type, payload, timestamp):
volume_id = payload['volume_id']
LOG.debug("Updating cinder volume information for %s", volume_id)
try:
volume_payload = serialize_cinder_volume(volume_id)
version = self.get_version(volume_payload, timestamp)
self.index_helper.save_document(volume_payload, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, volume_payload)
except cinderclient.exceptions.NotFound:
LOG.warning("Volume %s not found; deleting" % volume_id)
self.delete(payload, timestamp)
def create(self, event_type, payload, timestamp):
server_group = deepcopy(payload)
server_group['id'] = server_group.pop('server_group_id')
server_group['metadata'] = {}
server_group['members'] = []
server_group['updated_at'] = utils.get_now_str()
LOG.debug("creating nova server group "
"information for %s", server_group['id'])
version = self.get_version(server_group, timestamp)
self.index_helper.save_document(server_group, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, server_group)
def create_or_update(self, event_type, payload, timestamp):
serialized_payload = serialize_swift_container_notification(payload)
try:
self.index_helper.save_document(
serialized_payload,
version=self.get_version(serialized_payload, timestamp))
return pipeline.IndexItem(self.index_helper.plugin,
event_type,
payload,
serialized_payload)
except Exception as exc:
LOG.error('Error saving container %(id)s '
'in index. Error: %(exc)s' %
{'id': payload['id'], 'exc': exc})
def create_or_update_from_interface(self, event_type, payload, timestamp):
"""Unfortunately there seems to be no notification for ports created
as part of a router interface creation, nor for DHCP ports. This
means we need to go to the API.
"""
port_id = payload['router_interface']['port_id']
LOG.debug("Retrieving port %s from API", port_id)
nc = openstack_clients.get_neutronclient()
port = nc.show_port(port_id)['port']
serialized = serialize_port(port)
version = self.get_version(serialized, timestamp)
self.index_helper.save_document(serialized, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, serialized)
def rbac_delete(self, event_type, payload, timestamp):
"""RBAC policy is making a network invisible to users in specific
tenant. Previously this network was visible to users in that
tenant. We will remove this tenant from the members list.
Also remove the RBAC policy.
"""
policy_id = payload['rbac_policy_id']
# Read, modify, write an existing network document. For both the
# admin and user version of the document.
# Find all documents (admin and user) with the policy ID.
docs = self.index_helper.get_docs_by_nested_field("rbac_policy",
"rbac_id",
policy_id,
version=True)
if not docs or not docs['hits']['hits']:
return
for doc in docs['hits']['hits']:
if doc['_id'].endswith(USER_ID_SUFFIX):
# We only want to use the admin document.
continue
body = doc['_source']
target_tenant = None
policies = body['rbac_policy']
for p in policies:
if p.get('rbac_id') == policy_id:
target_tenant = p['target_tenant']
# Remove target_tenant from members list.
members_list = (body['members'])
if target_tenant in members_list:
members_list.remove(target_tenant)
body['members'] = members_list
# Remove RBAC policy.
new_list = [p for p in policies if p.get('rbac_id') != policy_id]
body['rbac_policy'] = new_list
# Bump version for race condition prevention. Use doc and not
# body, since '_version' is outside of '_source'.
version = doc['_version'] + 1
self.index_helper.save_document(body, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, body)
def create_rs(self, event_type, payload, timestamp):
id = payload['namespace']
resource_type = {}
resource_type['name'] = payload['name']
if payload['prefix']:
resource_type['prefix'] = payload['prefix']
if payload['properties_target']:
resource_type['properties_target'] = payload['properties_target']
preexisting = self.index_helper.get_document(id, for_admin=True)
self.create_entity(preexisting['_source'], "resource_types",
resource_type)
self.index_helper.save_document(preexisting['_source'],
preexisting['_version'] + 1)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, preexisting['_source'])
def process(self, ctxt, publisher_id, event_type, payload, metadata):
if (event_type == 'dns.zone.update' and
payload.get('status') == 'DELETED'):
LOG.debug("Ignoring update notification for Domain with DELETED "
"status; event will be processed on delete event")
return None
items = super(ZoneHandler, self).process(
ctxt, publisher_id, event_type, payload, metadata)
try:
# NOTE: So if this is an initial zone we need to index the SOA / NS
# records it will have. Let's do this when receiving the create
# event.
if event_type == 'dns.zone.create':
if not items:
LOG.warning(_LW("Not writing initial recordsets; exception"
"occurred during zone indexing"))
return None
recordsets = designate._get_recordsets(payload['id'])
serialized_recordsets = []
recordset_versions = []
for rs in recordsets:
rs = designate._serialize_recordset(rs)
# So project ID isn't provided in the recordset api.
rs['project_id'] = payload['project_id']
serialized_recordsets.append(rs)
# Use the timestamp from *this* notification but the
# updated_at from each recordset (which empirically appears
# to be the same for all initial recordsets)
recordset_versions.append(
self.get_version(rs, metadata['timestamp']))
items.append(
pipeline.IndexItem(self.recordset_helper.plugin,
event_type,
payload,
rs
)
)
self.recordset_helper.save_documents(
serialized_recordsets, versions=recordset_versions)
return items
except Exception as e:
LOG.exception(e)
def create_or_update_group(self, event_type, payload, timestamp):
group_name = payload['security_group']['name']
sec_id = payload['security_group']['id']
LOG.debug("Updating security group information for %(grp)s (%(sec)s)" %
{
'grp': group_name,
'sec': sec_id
})
# Version doesn't really make sense for security groups,
# but we need to normalize the fields.
doc = serialize_security_group(payload['security_group'])
version = self.get_version(doc, timestamp)
self.index_helper.save_document(doc, version=version)
return pipeline.IndexItem(self.index_helper.plugin, event_type,
payload, doc)
