You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by da...@apache.org on 2018/02/16 09:52:37 UTC
[21/30] atlas git commit: ATLAS-2246: OMRS Connector API plus REST
and IGC Connector skeleton - 15th February 2018
http://git-wip-us.apache.org/repos/asf/atlas/blob/8a57e657/omrs/src/main/java/org/apache/atlas/omrs/eventmanagement/OMRSEventPublisher.java
----------------------------------------------------------------------
diff --git a/omrs/src/main/java/org/apache/atlas/omrs/eventmanagement/OMRSEventPublisher.java b/omrs/src/main/java/org/apache/atlas/omrs/eventmanagement/OMRSEventPublisher.java
new file mode 100644
index 0000000..14a8e69
--- /dev/null
+++ b/omrs/src/main/java/org/apache/atlas/omrs/eventmanagement/OMRSEventPublisher.java
@@ -0,0 +1,1972 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * <p/>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p/>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.omrs.eventmanagement;
+
+import org.apache.atlas.ocf.properties.Connection;
+import org.apache.atlas.omrs.admin.properties.OpenMetadataEventProtocolVersion;
+import org.apache.atlas.omrs.auditlog.*;
+import org.apache.atlas.omrs.eventmanagement.events.*;
+import org.apache.atlas.omrs.ffdc.OMRSErrorCode;
+import org.apache.atlas.omrs.ffdc.exception.OMRSLogicErrorException;
+import org.apache.atlas.omrs.metadatacollection.properties.instances.EntityDetail;
+import org.apache.atlas.omrs.metadatacollection.properties.instances.InstanceProvenanceType;
+import org.apache.atlas.omrs.metadatacollection.properties.instances.Relationship;
+import org.apache.atlas.omrs.metadatacollection.properties.typedefs.AttributeTypeDef;
+import org.apache.atlas.omrs.metadatacollection.properties.typedefs.TypeDef;
+import org.apache.atlas.omrs.metadatacollection.properties.typedefs.TypeDefPatch;
+import org.apache.atlas.omrs.metadatacollection.properties.typedefs.TypeDefSummary;
+import org.apache.atlas.omrs.topicconnectors.OMRSTopicConnector;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Date;
+
+
+/**
+ * OMRSEventPublisher publishes OMRS Events to the supplied OMRSTopicConnector.
+ */
+public class OMRSEventPublisher implements OMRSRegistryEventProcessor, OMRSTypeDefEventProcessor, OMRSInstanceEventProcessor
+{
+ private static final OMRSAuditLog auditLog = new OMRSAuditLog(OMRSAuditingComponent.EVENT_PUBLISHER);
+
+ private static final Logger log = LoggerFactory.getLogger(OMRSEventPublisher.class);
+
+ private String publisherName = null;
+ private OMRSTopicConnector omrsTopicConnector = null;
+ private OpenMetadataEventProtocolVersion eventProtocolVersion = null;
+
+
+ /**
+ * Typical constructor sets up the local metadata collection id for events.
+ *
+ * @param publisherName - name of the cohort (or enterprise virtual repository) that this event publisher
+ * is sending events to.
+ * @param localProtocolVersion - protocol versionName to use
+ * @param topicConnector - OMRS Topic to send requests on
+ */
+ public OMRSEventPublisher(String publisherName,
+ OpenMetadataEventProtocolVersion localProtocolVersion,
+ OMRSTopicConnector topicConnector)
+ {
+ String actionDescription = "Initialize event publisher";
+
+ /*
+ * Save the publisherName and protocol versionName
+ */
+ this.eventProtocolVersion = localProtocolVersion;
+ this.publisherName = publisherName;
+
+ /*
+ * The topic connector is needed to publish events.
+ */
+ if (topicConnector == null)
+ {
+ if (log.isDebugEnabled())
+ {
+ log.debug("Null topic connector");
+ }
+
+ OMRSErrorCode errorCode = OMRSErrorCode.NULL_TOPIC_CONNECTOR;
+ String errorMessage = errorCode.getErrorMessageId()
+ + errorCode.getFormattedErrorMessage(publisherName);
+
+ throw new OMRSLogicErrorException(errorCode.getHTTPErrorCode(),
+ this.getClass().getName(),
+ actionDescription,
+ errorMessage,
+ errorCode.getSystemAction(),
+ errorCode.getUserAction());
+
+ }
+
+ this.omrsTopicConnector = topicConnector;
+
+
+ if (log.isDebugEnabled())
+ {
+ log.debug("New Event Publisher: " + publisherName);
+ }
+ }
+
+
+ /**
+ * Send the registry event to the OMRS Topic connector and manage errors
+ *
+ * @param registryEvent - properties of the event to send
+ * @return boolean flag to report if the call succeeded or not.
+ */
+ private boolean sendRegistryEvent(OMRSRegistryEvent registryEvent)
+ {
+ String actionDescription = "Send Registry Event";
+ boolean successFlag = false;
+
+ if (log.isDebugEnabled())
+ {
+ log.debug("Sending registryEvent for cohort: " + publisherName);
+ log.debug("topicConnector: " + omrsTopicConnector);
+ log.debug("registryEvent: " + registryEvent);
+ log.debug("localEventOriginator: " + registryEvent.getEventOriginator());
+ }
+
+ try
+ {
+ if (eventProtocolVersion == OpenMetadataEventProtocolVersion.V1)
+ {
+ omrsTopicConnector.sendEvent(registryEvent.getOMRSEventV1());
+ successFlag = true;
+ }
+ }
+ catch (Throwable error)
+ {
+ OMRSAuditCode auditCode = OMRSAuditCode.SEND_REGISTRY_EVENT_ERROR;
+
+ auditLog.logException(actionDescription,
+ auditCode.getLogMessageId(),
+ auditCode.getSeverity(),
+ auditCode.getFormattedLogMessage(publisherName),
+ "registryEvent : " + registryEvent.toString(),
+ auditCode.getSystemAction(),
+ auditCode.getUserAction(),
+ error);
+
+ if (log.isDebugEnabled())
+ {
+ log.debug("Exception: ", error, registryEvent);
+ }
+ }
+
+ return successFlag;
+ }
+
+
+ /**
+ * Send the TypeDef event to the OMRS Topic connector (providing TypeDef Events are enabled).
+ *
+ * @param typeDefEvent - properties of the event to send
+ * @return boolean flag to report if the call succeeded or not.
+ */
+ private boolean sendTypeDefEvent(OMRSTypeDefEvent typeDefEvent)
+ {
+ String actionDescription = "Send TypeDef Event";
+ boolean successFlag = false;
+
+ if (log.isDebugEnabled())
+ {
+ log.debug("Sending typeDefEvent for cohort: " + publisherName);
+ log.debug("topicConnector: ", omrsTopicConnector);
+ log.debug("typeDefEvent: ", typeDefEvent);
+ log.debug("localEventOriginator: ", typeDefEvent.getEventOriginator());
+ }
+
+ try
+ {
+ if (eventProtocolVersion == OpenMetadataEventProtocolVersion.V1)
+ {
+ omrsTopicConnector.sendEvent(typeDefEvent.getOMRSEventV1());
+ successFlag = true;
+ }
+ }
+ catch (Throwable error)
+ {
+ OMRSAuditCode auditCode = OMRSAuditCode.SEND_TYPEDEF_EVENT_ERROR;
+
+ auditLog.logException(actionDescription,
+ auditCode.getLogMessageId(),
+ auditCode.getSeverity(),
+ auditCode.getFormattedLogMessage(publisherName),
+ "typeDefEvent {" + typeDefEvent.toString() + "}",
+ auditCode.getSystemAction(),
+ auditCode.getUserAction(),
+ error);
+
+ if (log.isDebugEnabled())
+ {
+ log.debug("Exception: ", error);
+ }
+ }
+
+ return successFlag;
+ }
+
+
+ /**
+ * Set the instance event to the OMRS Topic connector if the instance
+ * event is of the permitted type.
+ *
+ * @param instanceEvent - properties of the event to send
+ * @return boolean flag to report if the call succeeded or not.
+ * */
+ private boolean sendInstanceEvent(OMRSInstanceEvent instanceEvent)
+ {
+ String actionDescription = "Send Instance Event";
+ boolean successFlag = false;
+
+ if (log.isDebugEnabled())
+ {
+ log.debug("Sending instanceEvent for cohort: " + publisherName);
+ log.debug("topicConnector: ", omrsTopicConnector);
+ log.debug("instanceEvent: ", instanceEvent);
+ log.debug("localEventOriginator: ", instanceEvent.getEventOriginator());
+ }
+
+ try
+ {
+ if (eventProtocolVersion == OpenMetadataEventProtocolVersion.V1)
+ {
+ omrsTopicConnector.sendEvent(instanceEvent.getOMRSEventV1());
+ successFlag = true;
+ }
+ }
+ catch (Throwable error)
+ {
+ OMRSAuditCode auditCode = OMRSAuditCode.SEND_INSTANCE_EVENT_ERROR;
+
+ auditLog.logException(actionDescription,
+ auditCode.getLogMessageId(),
+ auditCode.getSeverity(),
+ auditCode.getFormattedLogMessage(publisherName),
+ "instanceEvent {" + instanceEvent.toString() + "}",
+ auditCode.getSystemAction(),
+ auditCode.getUserAction(),
+ error);
+
+ if (log.isDebugEnabled())
+ {
+ log.debug("Exception: ", error);
+ }
+ }
+
+ return successFlag;
+ }
+
+
+ /**
+ * Introduces the local server/repository to the metadata repository cohort.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param metadataCollectionId - unique identifier for the metadata collection that is registering with the cohort.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param registrationTimestamp - the time that the server/repository issued the registration request.
+ * @param remoteConnection - the Connection properties for the connector used to call the registering server.
+ * @param typeDefList - the list of TypeDefs supported by the registering server/repository.
+ */
+ public boolean processRegistrationEvent(String sourceName,
+ String metadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ Date registrationTimestamp,
+ Connection remoteConnection,
+ ArrayList<TypeDefSummary> typeDefList)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(metadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSRegistryEvent registryEvent = new OMRSRegistryEvent(OMRSRegistryEventType.REGISTRATION_EVENT,
+ registrationTimestamp,
+ remoteConnection,
+ typeDefList);
+
+ registryEvent.setEventOriginator(eventOriginator);
+
+ return sendRegistryEvent(registryEvent);
+ }
+
+
+ /**
+ * Requests that the other servers in the cohort send re-registration events.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ */
+ public boolean processRegistrationRefreshRequest(String sourceName,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSRegistryEvent registryEvent = new OMRSRegistryEvent(OMRSRegistryEventType.REFRESH_REGISTRATION_REQUEST);
+
+ registryEvent.setEventOriginator(eventOriginator);
+
+ return sendRegistryEvent(registryEvent);
+ }
+
+
+ /**
+ * Refreshes the other servers in the cohort with the local server's registration.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param metadataCollectionId - unique identifier for the metadata collection that is registering with the cohort.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param registrationTimestamp - the time that the server/repository first registered with the cohort.
+ * @param remoteConnection - the Connection properties for the connector used to call the registering server.
+ * @param typeDefList - the list of TypeDefs supported by the registering server/repository.
+ */
+ public boolean processReRegistrationEvent(String sourceName,
+ String metadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ Date registrationTimestamp,
+ Connection remoteConnection,
+ ArrayList<TypeDefSummary> typeDefList)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(metadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSRegistryEvent registryEvent = new OMRSRegistryEvent(OMRSRegistryEventType.RE_REGISTRATION_EVENT,
+ registrationTimestamp,
+ remoteConnection,
+ typeDefList);
+
+ registryEvent.setEventOriginator(eventOriginator);
+
+ return sendRegistryEvent(registryEvent);
+ }
+
+
+ /**
+ * A server/repository is being removed from the metadata repository cohort.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param metadataCollectionId - unique identifier for the metadata collection that is registering with the cohort.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ */
+ public boolean processUnRegistrationEvent(String sourceName,
+ String metadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(metadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSRegistryEvent registryEvent = new OMRSRegistryEvent(OMRSRegistryEventType.UN_REGISTRATION_EVENT);
+
+ registryEvent.setEventOriginator(eventOriginator);
+
+ return sendRegistryEvent(registryEvent);
+ }
+
+
+ /**
+ * There is more than one member of the open metadata repository cohort that is using the same metadata
+ * collection Id. This means that their metadata instances can be updated in more than one server and there
+ * is a potential for data integrity issues.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param conflictingMetadataCollectionId - unique identifier for the remote metadata collection that is
+ * registering with the cohort.
+ * @param errorMessage - details of the conflict
+ */
+ public void processConflictingCollectionIdEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String conflictingMetadataCollectionId,
+ String errorMessage)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSRegistryEvent registryEvent = new OMRSRegistryEvent(OMRSRegistryEventErrorCode.CONFLICTING_COLLECTION_ID,
+ errorMessage,
+ conflictingMetadataCollectionId,
+ null);
+
+ registryEvent.setEventOriginator(eventOriginator);
+
+ sendRegistryEvent(registryEvent);
+ }
+
+
+ /**
+ * A connection to one of the members of the open metadata repository cohort is not usable by one of the members.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param targetMetadataCollectionId - Id for the repository with the bad remote connection.
+ * @param remoteConnection - the Connection properties for the connector used to call the registering server.
+ * @param errorMessage - details of the error that occurs when the connection is used.
+ */
+ public void processBadConnectionEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String targetMetadataCollectionId,
+ Connection remoteConnection,
+ String errorMessage)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSRegistryEvent registryEvent = new OMRSRegistryEvent(OMRSRegistryEventErrorCode.CONFLICTING_COLLECTION_ID,
+ errorMessage,
+ targetMetadataCollectionId,
+ remoteConnection);
+
+ registryEvent.setEventOriginator(eventOriginator);
+
+ sendRegistryEvent(registryEvent);
+ }
+
+
+ /**
+ * A new TypeDef has been defined.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDef - details of the new TypeDef
+ */
+ public void processNewTypeDefEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ TypeDef typeDef)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventType.NEW_TYPEDEF_EVENT, typeDef);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+ /**
+ * A new AttributeTypeDef has been defined in an open metadata repository.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param attributeTypeDef - details of the new AttributeTypeDef.
+ */
+ public void processNewAttributeTypeDefEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ AttributeTypeDef attributeTypeDef)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventType.NEW_ATTRIBUTE_TYPEDEF_EVENT, attributeTypeDef);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * An existing TypeDef has been updated.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDefPatch - details of the new versionName of the TypeDef
+ */
+ public void processUpdatedTypeDefEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ TypeDefPatch typeDefPatch)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventType.UPDATED_TYPEDEF_EVENT, typeDefPatch);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * An existing TypeDef has been deleted. Both the name and the GUID are provided to ensure the right TypeDef is
+ * deleted in remote repositories.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDefGUID - unique identifier of the TypeDef
+ * @param typeDefName - unique name of the TypeDef
+ */
+ public void processDeletedTypeDefEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String typeDefGUID,
+ String typeDefName)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventType.DELETED_TYPEDEF_EVENT,
+ typeDefGUID,
+ typeDefName);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * An existing AttributeTypeDef has been deleted in an open metadata repository. Both the name and the
+ * GUID are provided to ensure the right AttributeTypeDef is deleted in other cohort member repositories.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param attributeTypeDefGUID - unique identifier of the AttributeTypeDef
+ * @param attributeTypeDefName - unique name of the AttributeTypeDef
+ */
+ public void processDeletedAttributeTypeDefEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String attributeTypeDefGUID,
+ String attributeTypeDefName)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventType.DELETED_ATTRIBUTE_TYPEDEF_EVENT,
+ attributeTypeDefGUID,
+ attributeTypeDefName);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * The guid or name of an existing TypeDef has been changed to a new value. This is used if two different
+ * Typedefs are discovered to have either the same guid or, most likely, the same name. This type of conflict
+ * is rare but typically occurs when a new repository joins the cohort.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param originalTypeDefSummary - the details for the original TypeDef.
+ * @param typeDef - updated TypeDef with new identifiers
+ */
+ public void processReIdentifiedTypeDefEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ TypeDefSummary originalTypeDefSummary,
+ TypeDef typeDef)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventType.RE_IDENTIFIED_TYPEDEF_EVENT,
+ originalTypeDefSummary,
+ typeDef);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+ /**
+ * Process an event that changes either the name or guid of an AttributeTypeDef.
+ * It is resolving a Conflicting AttributeTypeDef Error.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param originalAttributeTypeDef - description of original AttributeTypeDef
+ * @param attributeTypeDef - updated AttributeTypeDef with new identifiers inside.
+ */
+ public void processReIdentifiedAttributeTypeDefEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ AttributeTypeDef originalAttributeTypeDef,
+ AttributeTypeDef attributeTypeDef)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventType.RE_IDENTIFIED_ATTRIBUTE_TYPEDEF_EVENT,
+ originalAttributeTypeDef,
+ attributeTypeDef);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * Process a detected conflict in type definitions (TypeDefs) used in the cohort.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param originatorTypeDefSummary - details of the TypeDef in the event originator
+ * @param otherMetadataCollectionId - the metadataCollection using the conflicting TypeDef
+ * @param conflictingTypeDefSummary - the details of the TypeDef in the other metadata collection
+ * @param errorMessage - details of the error that occurs when the connection is used.
+ */
+ public void processTypeDefConflictEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ TypeDefSummary originatorTypeDefSummary,
+ String otherMetadataCollectionId,
+ TypeDefSummary conflictingTypeDefSummary,
+ String errorMessage)
+
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventErrorCode.CONFLICTING_TYPEDEFS,
+ errorMessage,
+ originatorMetadataCollectionId,
+ originatorTypeDefSummary,
+ conflictingTypeDefSummary);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * Process a detected conflict in the attribute type definitions (AttributeTypeDefs) used in the cohort.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param originatorAttributeTypeDef- description of the AttributeTypeDef in the event originator.
+ * @param otherMetadataCollectionId - the metadataCollection using the conflicting AttributeTypeDef.
+ * @param conflictingAttributeTypeDef - description of the AttributeTypeDef in the other metadata collection.
+ * @param errorMessage - details of the error that occurs when the connection is used.
+ */
+ public void processAttributeTypeDefConflictEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ AttributeTypeDef originatorAttributeTypeDef,
+ String otherMetadataCollectionId,
+ AttributeTypeDef conflictingAttributeTypeDef,
+ String errorMessage)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventErrorCode.CONFLICTING_ATTRIBUTE_TYPEDEFS,
+ errorMessage,
+ originatorMetadataCollectionId,
+ originatorAttributeTypeDef,
+ conflictingAttributeTypeDef);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * A TypeDef from another member in the cohort is at a different versionName than the local repository. This may
+ * create some inconsistencies in the different copies of instances of this type in different members of the
+ * cohort. The recommended action is to update all TypeDefs to the latest versionName.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param targetMetadataCollectionId - identifier of the metadata collection that is reporting a TypeDef at a
+ * different level to the local repository.
+ * @param targetTypeDefSummary - details of the TypeDef being patched
+ * @param otherTypeDef - details of the TypeDef in the local repository.
+ */
+ public void processTypeDefPatchMismatchEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String targetMetadataCollectionId,
+ TypeDefSummary targetTypeDefSummary,
+ TypeDef otherTypeDef,
+ String errorMessage)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+
+
+ OMRSTypeDefEvent typeDefEvent = new OMRSTypeDefEvent(OMRSTypeDefEventErrorCode.TYPEDEF_PATCH_MISMATCH,
+ errorMessage,
+ targetMetadataCollectionId,
+ targetTypeDefSummary,
+ otherTypeDef);
+
+ typeDefEvent.setEventOriginator(eventOriginator);
+
+ this.sendTypeDefEvent(typeDefEvent);
+ }
+
+
+ /**
+ * A new entity has been created.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the new entity
+ */
+ public void processNewEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.NEW_ENTITY_EVENT,
+ entity);
+
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An existing entity has been updated.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the new versionName of the entity.
+ */
+ public void processUpdatedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.UPDATED_ENTITY_EVENT,
+ entity);
+
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An update to an entity has been undone.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the versionName of the entity that has been restored.
+ */
+ public void processUndoneEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.UNDONE_ENTITY_EVENT,
+ entity);
+
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * A new classification has been added to an entity.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the entity with the new classification added.
+ */
+ public void processClassifiedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.CLASSIFIED_ENTITY_EVENT,
+ entity);
+
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * A classification has been removed from an entity.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the entity after the classification has been removed.
+ */
+ public void processDeclassifiedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.DECLASSIFIED_ENTITY_EVENT,
+ entity);
+
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An existing classification has been changed on an entity.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the entity after the classification has been changed.
+ */
+ public void processReclassifiedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.RECLASSIFIED_ENTITY_EVENT,
+ entity);
+
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An existing entity has been deleted. This is a soft delete. This means it is still in the repository
+ * but it is no longer returned on queries.
+ *
+ * All relationships to the entity are also soft-deleted and will no longer be usable. These deleted relationships
+ * will be notified through separate events.
+ *
+ * Details of the TypeDef are included with the entity's unique id (guid) to ensure the right entity is deleted in
+ * the remote repositories.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDefGUID - unique identifier for this entity's TypeDef
+ * @param typeDefName - name of this entity's TypeDef
+ * @param instanceGUID - unique identifier for the entity
+ */
+ public void processDeletedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String typeDefGUID,
+ String typeDefName,
+ String instanceGUID)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.DELETED_ENTITY_EVENT,
+ typeDefGUID,
+ typeDefName,
+ instanceGUID);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * A deleted entity has been permanently removed from the repository. This request can not be undone.
+ *
+ * Details of the TypeDef are included with the entity's unique id (guid) to ensure the right entity is purged in
+ * the remote repositories.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDefGUID - unique identifier for this entity's TypeDef
+ * @param typeDefName - name of this entity's TypeDef
+ * @param instanceGUID - unique identifier for the entity
+ */
+ public void processPurgedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String typeDefGUID,
+ String typeDefName,
+ String instanceGUID)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.PURGED_ENTITY_EVENT,
+ typeDefGUID,
+ typeDefName,
+ instanceGUID);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * A deleted entity has been restored to the state it was before it was deleted.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the versionName of the entity that has been restored.
+ */
+ public void processRestoredEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.RESTORED_ENTITY_EVENT,
+ entity);
+
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * The guid of an existing entity has been changed to a new value. This is used if two different
+ * entities are discovered to have the same guid. This is extremely unlikely but not impossible so
+ * the open metadata protocol has provision for this.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param originalEntityGUID - the existing identifier for the entity.
+ * @param entity - new values for this entity, including the new guid.
+ */
+ public void processReIdentifiedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String originalEntityGUID,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.RE_IDENTIFIED_ENTITY_EVENT,
+ entity);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+ instanceEvent.setOriginalInstanceGUID(originalEntityGUID);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An existing entity has had its type changed. Typically this action is taken to move an entity's
+ * type to either a super type (so the subtype can be deleted) or a new subtype (so additional properties can be
+ * added.) However, the type can be changed to any compatible type.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param originalTypeDefSummary - original details for this entity's TypeDef.
+ * @param entity - new values for this entity, including the new type information.
+ */
+ public void processReTypedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ TypeDefSummary originalTypeDefSummary,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.RETYPED_ENTITY_EVENT,
+ entity);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+ instanceEvent.setOriginalTypeDefSummary(originalTypeDefSummary);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An existing entity has changed home repository. This action is taken for example, if a repository
+ * becomes permanently unavailable, or if the user community updating this entity move to working
+ * from a different repository in the open metadata repository cohort.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param originalHomeMetadataCollectionId - unique identifier for the original home repository.
+ * @param entity - new values for this entity, including the new home information.
+ */
+ public void processReHomedEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String originalHomeMetadataCollectionId,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.RE_HOMED_ENTITY_EVENT,
+ entity);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+ instanceEvent.setOriginalHomeMetadataCollectionId(originalHomeMetadataCollectionId);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * The local repository is requesting that an entity from another repository's metadata collection is
+ * refreshed so the local repository can create a reference copy.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDefGUID - - unique identifier for this entity's TypeDef
+ * @param typeDefName - name of this entity's TypeDef
+ * @param instanceGUID - unique identifier for the entity
+ * @param homeMetadataCollectionId - metadata collection id for the home of this instance.
+ */
+ public void processRefreshEntityRequested(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String typeDefGUID,
+ String typeDefName,
+ String instanceGUID,
+ String homeMetadataCollectionId)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.REFRESH_ENTITY_REQUEST,
+ typeDefGUID,
+ typeDefName,
+ instanceGUID);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+ instanceEvent.setHomeMetadataCollectionId(homeMetadataCollectionId);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * A remote repository in the cohort has sent entity details in response to a refresh request.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param entity - details of the requested entity
+ */
+ public void processRefreshEntityEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ EntityDetail entity)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.REFRESHED_ENTITY_EVENT,
+ entity);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * A new relationship has been created.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param relationship - details of the new relationship
+ */
+ public void processNewRelationshipEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ Relationship relationship)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.NEW_RELATIONSHIP_EVENT,
+ relationship);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An existing relationship has been updated.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param relationship - details of the new versionName of the relationship.
+ */
+ public void processUpdatedRelationshipEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ Relationship relationship)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.UPDATED_RELATIONSHIP_EVENT,
+ relationship);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * An update to a relationship has been undone.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param relationship - details of the versionName of the relationship that has been restored.
+ */
+ public void processUndoneRelationshipEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ Relationship relationship)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.UNDONE_RELATIONSHIP_EVENT,
+ relationship);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+ /**
+ * An existing relationship has been deleted. This is a soft delete. This means it is still in the repository
+ * but it is no longer returned on queries.
+ *
+ * Details of the TypeDef are included with the relationship's unique id (guid) to ensure the right
+ * relationship is deleted in the remote repositories.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDefGUID - unique identifier for this relationship's TypeDef
+ * @param typeDefName - name of this relationship's TypeDef
+ * @param instanceGUID - unique identifier for the relationship
+ */
+ public void processDeletedRelationshipEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServerType,
+ String originatorOrganizationName,
+ String typeDefGUID,
+ String typeDefName,
+ String instanceGUID)
+ {
+ OMRSEventOriginator eventOriginator = new OMRSEventOriginator();
+
+ eventOriginator.setMetadataCollectionId(originatorMetadataCollectionId);
+ eventOriginator.setServerName(originatorServerName);
+ eventOriginator.setServerType(originatorServerType);
+ eventOriginator.setOrganizationName(originatorOrganizationName);
+
+ OMRSInstanceEvent instanceEvent = new OMRSInstanceEvent(OMRSInstanceEventType.DELETED_RELATIONSHIP_EVENT,
+ typeDefGUID,
+ typeDefName,
+ instanceGUID);
+
+ instanceEvent.setEventOriginator(eventOriginator);
+
+ this.sendInstanceEvent(instanceEvent);
+ }
+
+
+ /**
+ * A deleted relationship has been permanently removed from the repository. This request can not be undone.
+ *
+ * Details of the TypeDef are included with the relationship's unique id (guid) to ensure the right
+ * relationship is purged in the remote repositories.
+ *
+ * @param sourceName - name of the source of the event. It may be the cohort name for incoming events or the
+ * local repository, or event mapper name.
+ * @param originatorMetadataCollectionId - unique identifier for the metadata collection hosted by the server that
+ * sent the event.
+ * @param originatorServerName - name of the server that the event came from.
+ * @param originatorServerType - type of server that the event came from.
+ * @param originatorOrganizationName - name of the organization that owns the server that sent the event.
+ * @param typeDefGUID - unique identifier for this relationship's TypeDef.
+ * @param typeDefName - name of this relationship's TypeDef.
+ * @param instanceGUID - unique identifier for the relationship.
+ */
+ public void processPurgedRelationshipEvent(String sourceName,
+ String originatorMetadataCollectionId,
+ String originatorServerName,
+ String originatorServe
<TRUNCATED>