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/04/06 08:28:30 UTC
[26/31] atlas git commit: ATLAS-2122 OMAG Server Application and OMRS
APIs
http://git-wip-us.apache.org/repos/asf/atlas/blob/a1fd4068/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataStore.java
----------------------------------------------------------------------
diff --git a/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataStore.java b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataStore.java
new file mode 100644
index 0000000..6b9bfd5
--- /dev/null
+++ b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataStore.java
@@ -0,0 +1,634 @@
+/*
+ * 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.adapters.inmemory.repositoryconnector;
+
+import org.apache.atlas.omrs.ffdc.OMRSErrorCode;
+import org.apache.atlas.omrs.ffdc.exception.InvalidParameterException;
+import org.apache.atlas.omrs.metadatacollection.properties.instances.EntityDetail;
+import org.apache.atlas.omrs.metadatacollection.properties.instances.EntityProxy;
+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 java.util.*;
+
+/**
+ * InMemoryOMRSMetadataStore provides the in memory stores for the InMemoryRepositoryConnector
+ */
+public class InMemoryOMRSMetadataStore
+{
+ private String repositoryName = null;
+ private HashMap<String, TypeDef> typeDefStore = new HashMap<>();
+ private HashMap<String, AttributeTypeDef> attributeTypeDefStore = new HashMap<>();
+ private HashMap<String, EntityDetail> entityStore = new HashMap<>();
+ private HashMap<String, EntityProxy> entityProxyStore = new HashMap<>();
+ private List<EntityDetail> entityHistoryStore = new ArrayList<>();
+ private HashMap<String, Relationship> relationshipStore = new HashMap<>();
+ private List<Relationship> relationshipHistoryStore = new ArrayList<>();
+
+
+ /**
+ * Default constructor
+ */
+ public InMemoryOMRSMetadataStore()
+ {
+ }
+
+
+ /**
+ * Set up the name of the repository for logging.
+ *
+ * @param repositoryName - String name
+ */
+ protected void setRepositoryName(String repositoryName)
+ {
+ this.repositoryName = repositoryName;
+ }
+
+
+ /**
+ * Return a list of all of the defined AttributeTypeDefs.
+ *
+ * @return list of attribute type definitions
+ */
+ protected List<AttributeTypeDef> getAttributeTypeDefs()
+ {
+ return new ArrayList<>(attributeTypeDefStore.values());
+ }
+
+
+ /**
+ * Return the AttributeTypeDef identified by the supplied guid.
+ *
+ * @param guid - unique identifier for the AttributeTypeDef
+ * @return attribute type definition
+ */
+ protected AttributeTypeDef getAttributeTypeDef(String guid)
+ {
+ return attributeTypeDefStore.get(guid);
+ }
+
+
+ /**
+ * Add an AttributeDefType to the store.
+ *
+ * @param attributeTypeDef - type to add
+ */
+ protected void putAttributeTypeDef(AttributeTypeDef attributeTypeDef)
+ {
+ attributeTypeDefStore.put(attributeTypeDef.getGUID(), attributeTypeDef);
+ }
+
+
+ /**
+ * Return a list of all of the defined TypeDefs.
+ *
+ * @return list of type definitions
+ */
+ protected List<TypeDef> getTypeDefs()
+ {
+ return new ArrayList<>(typeDefStore.values());
+ }
+
+
+ /**
+ * Return the type definition identified by the guid.
+ *
+ * @param guid - unique identifier for type definition
+ * @return type definition
+ */
+ protected TypeDef getTypeDef(String guid)
+ {
+ return typeDefStore.get(guid);
+ }
+
+
+ /**
+ * Add a type definition (TypeDef) to the store.
+ *
+ * @param typeDef - type definition
+ */
+ protected void putTypeDef(TypeDef typeDef)
+ {
+ typeDefStore.put(typeDef.getGUID(), typeDef);
+ }
+
+
+ /**
+ * Return a list of entities from the store that are at the latest level.
+ *
+ * @return
+ */
+ protected List<EntityDetail> getEntities()
+ {
+ return new ArrayList<>(entityStore.values());
+ }
+
+
+ /**
+ * Return the entity identified by the guid.
+ *
+ * @param guid - unique identifier for the entity
+ * @return entity object
+ */
+ protected EntityDetail getEntity(String guid)
+ {
+ return entityStore.get(guid);
+ }
+
+
+ /**
+ * Return the entity proxy identified by the guid.
+ *
+ * @param guid - unique identifier
+ * @return entity proxy object
+ */
+ protected EntityProxy getEntityProxy(String guid)
+ {
+ return entityProxyStore.get(guid);
+ }
+
+
+ /**
+ * Return an entity store that contains entities as they were at the time supplied in the asOfTime
+ * parameter
+ *
+ * @param methodName - name of the method requesting the store
+ * @param asOfTime - time for the store (or null means now)
+ * @return entity store for the requested time
+ * @throws InvalidParameterException - asOfTime is for the future.
+ */
+ protected HashMap<String, EntityDetail> timeWarpEntityStore(String methodName,
+ Date asOfTime) throws InvalidParameterException
+ {
+ final String asOfTimeParameterName = "asOfTime";
+
+ if (asOfTime == null)
+ {
+ return entityStore;
+ }
+
+ Date now = new Date();
+
+ if (asOfTime.after(now))
+ {
+ OMRSErrorCode errorCode = OMRSErrorCode.REPOSITORY_NOT_CRYSTAL_BALL;
+ String errorMessage = errorCode.getErrorMessageId()
+ + errorCode.getFormattedErrorMessage(asOfTime.toString(),
+ asOfTimeParameterName,
+ methodName,
+ repositoryName);
+
+ throw new InvalidParameterException(errorCode.getHTTPErrorCode(),
+ this.getClass().getName(),
+ methodName,
+ errorMessage,
+ errorCode.getSystemAction(),
+ errorCode.getUserAction());
+ }
+
+
+ HashMap<String, EntityDetail> timeWarpedEntityStore = new HashMap<>();
+
+ /*
+ * First step through the current relationship store and extract all of the relationships that were
+ * last updated before the asOfTime.
+ */
+ for (EntityDetail entity : entityStore.values())
+ {
+ if (entity != null)
+ {
+ if (entity.getUpdateTime() != null)
+ {
+ String entityGUID = entity.getGUID();
+
+ if (entityGUID != null)
+ {
+ if (! entity.getUpdateTime().after(asOfTime))
+ {
+ timeWarpedEntityStore.put(entityGUID, entity);
+ }
+ }
+ }
+ else if (entity.getCreateTime() != null)
+ {
+ if (! entity.getCreateTime().after(asOfTime))
+ {
+ timeWarpedEntityStore.put(entity.getGUID(), entity);
+ }
+ }
+ }
+ }
+
+ /*
+ * Now step through the history store picking up the versions of other entities that were active
+ * at the time of the asOfTime.
+ */
+ for (EntityDetail oldEntity : entityHistoryStore)
+ {
+ if (oldEntity != null)
+ {
+ String entityGUID = oldEntity.getGUID();
+
+ if (oldEntity.getUpdateTime() != null)
+ {
+ if (! oldEntity.getUpdateTime().after(asOfTime))
+ {
+ EntityDetail newerEntity = timeWarpedEntityStore.put(entityGUID, oldEntity);
+
+ if (newerEntity != null)
+ {
+ timeWarpedEntityStore.put(entityGUID, newerEntity);
+ }
+ break;
+ }
+ }
+ else if (oldEntity.getCreateTime() != null)
+ {
+ if (! oldEntity.getCreateTime().after(asOfTime))
+ {
+ timeWarpedEntityStore.put(entityGUID, oldEntity);
+ break;
+ }
+ }
+ }
+ }
+
+ return timeWarpedEntityStore;
+ }
+
+
+ /**
+ * Return the list of relationships at their current level.
+ *
+ * @return list of relationships
+ */
+ protected List<Relationship> getRelationships()
+ {
+ return new ArrayList<>(relationshipStore.values());
+ }
+
+
+ /**
+ * Return the relationship identified by the guid.
+ *
+ * @param guid - unique identifier for the relationship
+ * @return relationship object
+ */
+ protected Relationship getRelationship(String guid)
+ {
+ return relationshipStore.get(guid);
+ }
+
+ /**
+ * Return a relationship store that contains relationships as they were at the time supplied in the asOfTime
+ * parameter
+ *
+ * @param methodName - name of the method requesting the store
+ * @param asOfTime - time for the store (or null means now)
+ * @return relationship store for the requested time
+ * @throws InvalidParameterException - asOfTime is for the future.
+ */
+ protected HashMap<String, Relationship> timeWarpRelationshipStore(String methodName,
+ Date asOfTime) throws InvalidParameterException
+ {
+ final String asOfTimeParameterName = "asOfTime";
+
+ if (asOfTime == null)
+ {
+ return relationshipStore;
+ }
+
+ Date now = new Date();
+
+ if (asOfTime.after(now))
+ {
+ OMRSErrorCode errorCode = OMRSErrorCode.REPOSITORY_NOT_CRYSTAL_BALL;
+ String errorMessage = errorCode.getErrorMessageId()
+ + errorCode.getFormattedErrorMessage(asOfTime.toString(),
+ asOfTimeParameterName,
+ methodName,
+ repositoryName);
+
+ throw new InvalidParameterException(errorCode.getHTTPErrorCode(),
+ this.getClass().getName(),
+ methodName,
+ errorMessage,
+ errorCode.getSystemAction(),
+ errorCode.getUserAction());
+ }
+
+
+ HashMap<String, Relationship> timeWarpedRelationshipStore = new HashMap<>();
+
+ /*
+ * First step through the current relationship store and extract all of the relationships that were
+ * last updated before the asOfTime.
+ */
+ for (Relationship relationship : relationshipStore.values())
+ {
+ if (relationship != null)
+ {
+ if (relationship.getUpdateTime() != null)
+ {
+ String relationshipGUID = relationship.getGUID();
+
+ if (relationshipGUID != null)
+ {
+ if (! relationship.getUpdateTime().after(asOfTime))
+ {
+ timeWarpedRelationshipStore.put(relationshipGUID, relationship);
+ }
+ }
+ }
+ else if (relationship.getCreateTime() != null)
+ {
+ if (! relationship.getCreateTime().after(asOfTime))
+ {
+ timeWarpedRelationshipStore.put(relationship.getGUID(), relationship);
+ }
+ }
+ }
+ }
+
+ /*
+ * Now step through the history store picking up the versions of other relationships that were active
+ * at the time of the asOfTime.
+ */
+ for (Relationship oldRelationship : relationshipHistoryStore)
+ {
+ if (oldRelationship != null)
+ {
+ String relationshipGUID = oldRelationship.getGUID();
+
+ if (oldRelationship.getUpdateTime() != null)
+ {
+ if (! oldRelationship.getUpdateTime().after(asOfTime))
+ {
+ Relationship newerRelationship = timeWarpedRelationshipStore.put(relationshipGUID, oldRelationship);
+
+ if (newerRelationship != null)
+ {
+ timeWarpedRelationshipStore.put(relationshipGUID, newerRelationship);
+ }
+ break;
+ }
+ }
+ else if (oldRelationship.getCreateTime() != null)
+ {
+ if (! oldRelationship.getCreateTime().after(asOfTime))
+ {
+ timeWarpedRelationshipStore.put(relationshipGUID, oldRelationship);
+ break;
+ }
+ }
+ }
+ }
+
+ return timeWarpedRelationshipStore;
+ }
+
+ /**
+ * Create a new entity in the entity store.
+ *
+ * @param entity - new version of the entity
+ * @return entity with potentially updated GUID
+ */
+ protected EntityDetail createEntityInStore(EntityDetail entity)
+ {
+ /*
+ * There is a small chance the randomly generated GUID will clash with an existing relationship.
+ * If this happens a new GUID is generated for the relationship and the process repeats.
+ */
+ EntityDetail existingEntity = entityStore.put(entity.getGUID(), entity);
+
+ while (existingEntity != null)
+ {
+ entity.setGUID(UUID.randomUUID().toString());
+ existingEntity = entityStore.put(entity.getGUID(), entity);
+ }
+
+ return entity;
+ }
+
+
+ /**
+ * Create a new relationship in the relationship store.
+ *
+ * @param relationship - new version of the relationship
+ * @return relationship with potentially updated GUID
+ */
+ protected Relationship createRelationshipInStore(Relationship relationship)
+ {
+ /*
+ * There is a small chance the randomly generated GUID will clash with an existing relationship.
+ * If this happens a new GUID is generated for the relationship and the process repeats.
+ */
+ Relationship existingRelationship = relationshipStore.put(relationship.getGUID(), relationship);
+
+ while (existingRelationship != null)
+ {
+ relationship.setGUID(UUID.randomUUID().toString());
+ existingRelationship = relationshipStore.put(relationship.getGUID(), relationship);
+ }
+
+ return relationship;
+ }
+
+
+ /**
+ * Save an entity proxy to the entity store.
+ *
+ * @param entityProxy - entity proxy object to add
+ */
+ protected void addEntityProxyToStore(EntityProxy entityProxy)
+ {
+ entityProxyStore.put(entityProxy.getGUID(), entityProxy);
+ }
+
+
+ /**
+ * Maintain a history of entities as they are stored into the entity store to ensure old version can be restored.
+ * The history is maintained with the latest changes first in the list.
+ *
+ * @param entity - new version of the entity
+ */
+ protected void updateEntityInStore(EntityDetail entity)
+ {
+ EntityDetail oldEntity = entityStore.put(entity.getGUID(), entity);
+
+ if (oldEntity != null)
+ {
+ entityHistoryStore.add(0, oldEntity);
+ }
+ }
+
+
+ /**
+ * Update an entity proxy in the proxy store.
+ *
+ * @param entityProxy - entity proxy object to add
+ */
+ protected void updateEntityProxyInStore(EntityProxy entityProxy)
+ {
+ entityProxyStore.put(entityProxy.getGUID(), entityProxy);
+ }
+
+
+
+ /**
+ * Maintain a history of relationships as they are stored into the relationship store to ensure old version
+ * can be restored. The history is maintained with the latest changes first in the list.
+ *
+ * @param relationship - new version of the relationship
+ */
+ protected void updateRelationshipInStore(Relationship relationship)
+ {
+ Relationship oldRelationship = relationshipStore.put(relationship.getGUID(), relationship);
+
+ if (oldRelationship != null)
+ {
+ relationshipHistoryStore.add(0, oldRelationship);
+ }
+ }
+
+
+ /**
+ * Save a reference copy of an entity to the active store. Reference copies are not maintained in the
+ * history store.
+ *
+ * @param entity - object to save
+ */
+ protected void saveReferenceEntityToStore(EntityDetail entity)
+ {
+ entityStore.put(entity.getGUID(), entity);
+ }
+
+
+ /**
+ * Save a reference copy of a relationship to the active store. Reference copies are not maintained in the
+ * history store.
+ *
+ * @param relationship - object to save
+ */
+ protected void saveReferenceRelationshipToStore(Relationship relationship)
+ {
+ relationshipStore.put(relationship.getGUID(), relationship);
+ }
+
+
+ /**
+ * Retrieve the previous version of a Relationship. This is the first instance of this element that
+ * appears in the history.
+ *
+ * @param guid - unique identifier for the required element
+ * @return - previous version of this relationship - or null if not found
+ */
+ protected Relationship retrievePreviousVersionOfRelationship(String guid)
+ {
+ if (guid != null)
+ {
+ int elementPosition = 0;
+
+ for (Relationship relationship : relationshipHistoryStore)
+ {
+ if (relationship != null)
+ {
+ if (guid.equals(relationship.getGUID()))
+ {
+ relationshipHistoryStore.remove(elementPosition);
+ relationshipStore.put(guid, relationship);
+ return relationship;
+ }
+ }
+
+ elementPosition ++;
+ }
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Retrieve the previous version of an Entity from the history store and restore it in the entity store.
+ * This is the first instance of this element that appears in the history.
+ *
+ * @param guid - unique identifier for the required element
+ * @return - previous version of this Entity - or null if not found
+ */
+ protected EntityDetail retrievePreviousVersionOfEntity(String guid)
+ {
+ if (guid != null)
+ {
+ int elementPosition = 0;
+
+ for (EntityDetail entity : entityHistoryStore)
+ {
+ if (entity != null)
+ {
+ if (guid.equals(entity.getGUID()))
+ {
+ entityHistoryStore.remove(elementPosition);
+ entityStore.put(guid, entity);
+ return entity;
+ }
+ }
+
+ elementPosition ++;
+ }
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Remove an entity from the active store and add it to the history store.
+ *
+ * @param entity - entity to remove
+ */
+ protected void removeEntityFromStore(EntityDetail entity)
+ {
+ entityStore.remove(entity.getGUID());
+ entityHistoryStore.add(0, entity);
+ }
+
+ /**
+ * Remove an entity from the active store and add it to the history store.
+ *
+ * @param guid - entity proxy to remove
+ */
+ protected void removeEntityProxyFromStore(String guid)
+ {
+ entityProxyStore.remove(guid);
+ }
+
+
+ /**
+ * Remove a relationship from the active store and add it to the history store.
+ *
+ * @param relationship - relationship to remove
+ */
+ protected void removeRelationshipFromStore(Relationship relationship)
+ {
+ relationshipStore.remove(relationship.getGUID());
+ relationshipHistoryStore.add(0, relationship);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/atlas/blob/a1fd4068/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnector.java
----------------------------------------------------------------------
diff --git a/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnector.java b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnector.java
new file mode 100644
index 0000000..56dbb96
--- /dev/null
+++ b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnector.java
@@ -0,0 +1,58 @@
+/*
+ * 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.adapters.inmemory.repositoryconnector;
+
+import org.apache.atlas.omrs.metadatacollection.repositoryconnector.OMRSRepositoryConnector;
+
+/**
+ * The InMemoryOMRSRepositoryConnector is a connector to a local in memory repository. It is used for test,
+ * small scale fixed or temporary repositories where the initial content comes from open metadata archives and
+ * other members of connected open metadata repository cohorts.
+ */
+public class InMemoryOMRSRepositoryConnector extends OMRSRepositoryConnector
+{
+ /**
+ * Default constructor used by the OCF Connector Provider.
+ */
+ public InMemoryOMRSRepositoryConnector()
+ {
+ /*
+ * Nothing to do.
+ */
+ }
+
+
+ /**
+ * Set up the unique Id for this metadata collection.
+ *
+ * @param metadataCollectionId - String unique Id
+ */
+ public void setMetadataCollectionId(String metadataCollectionId)
+ {
+ super.metadataCollectionId = metadataCollectionId;
+
+ /*
+ * Initialize the metadata collection only once the connector is properly set up.
+ */
+ super.metadataCollection = new InMemoryOMRSMetadataCollection(this,
+ super.serverName,
+ repositoryHelper,
+ repositoryValidator,
+ metadataCollectionId);
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/atlas/blob/a1fd4068/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnectorProvider.java
----------------------------------------------------------------------
diff --git a/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnectorProvider.java b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnectorProvider.java
new file mode 100644
index 0000000..0b727e9
--- /dev/null
+++ b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSRepositoryConnectorProvider.java
@@ -0,0 +1,45 @@
+/*
+ * 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.adapters.inmemory.repositoryconnector;
+
+import org.apache.atlas.omrs.metadatacollection.repositoryconnector.OMRSRepositoryConnectorProviderBase;
+
+/**
+ * In the Open Connector Framework (OCF), a ConnectorProvider is a factory for a specific type of connector.
+ * The InMemoryOMRSRepositoryConnectorProvider is the connector provider for the InMemoryOMRSRepositoryConnector.
+ * It extends OMRSRepositoryConnectorProviderBase which in turn extends the OCF ConnectorProviderBase.
+ * ConnectorProviderBase supports the creation of connector instances.
+ *
+ * The InMemoryOMRSRepositoryConnectorProvider must initialize ConnectorProviderBase with the Java class
+ * name of the OMRS Connector implementation (by calling super.setConnectorClassName(className)).
+ * Then the connector provider will work.
+ */
+public class InMemoryOMRSRepositoryConnectorProvider
+ extends OMRSRepositoryConnectorProviderBase
+{
+ /**
+ * Constructor used to initialize the ConnectorProviderBase with the Java class name of the specific
+ * OMRS Connector implementation.
+ */
+ public InMemoryOMRSRepositoryConnectorProvider()
+ {
+ Class connectorClass = InMemoryOMRSRepositoryConnector.class;
+
+ super.setConnectorClassName(connectorClass.getName());
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/atlas/blob/a1fd4068/omrs/src/main/java/org/apache/atlas/omrs/admin/OMRSConfigurationFactory.java
----------------------------------------------------------------------
diff --git a/omrs/src/main/java/org/apache/atlas/omrs/admin/OMRSConfigurationFactory.java b/omrs/src/main/java/org/apache/atlas/omrs/admin/OMRSConfigurationFactory.java
index c626fa0..0f7bd01 100644
--- a/omrs/src/main/java/org/apache/atlas/omrs/admin/OMRSConfigurationFactory.java
+++ b/omrs/src/main/java/org/apache/atlas/omrs/admin/OMRSConfigurationFactory.java
@@ -17,173 +17,636 @@
*/
package org.apache.atlas.omrs.admin;
-import org.apache.atlas.ocf.properties.*;
+import org.apache.atlas.ocf.properties.ElementOrigin;
+import org.apache.atlas.ocf.properties.beans.Connection;
+import org.apache.atlas.ocf.properties.beans.ConnectorType;
+import org.apache.atlas.ocf.properties.beans.Endpoint;
+import org.apache.atlas.ocf.properties.beans.ElementType;
+
+
+import org.apache.atlas.omrs.adapters.atlas.repositoryconnector.LocalAtlasOMRSRepositoryConnectorProvider;
+import org.apache.atlas.omrs.adapters.inmemory.repositoryconnector.InMemoryOMRSRepositoryConnectorProvider;
import org.apache.atlas.omrs.admin.properties.*;
+import org.apache.atlas.omrs.archivemanager.store.file.FileBasedOpenMetadataArchiveStoreProvider;
+import org.apache.atlas.omrs.auditlog.store.file.FileBasedAuditLogStoreProvider;
import org.apache.atlas.omrs.metadatahighway.cohortregistry.store.file.FileBasedRegistryStoreProvider;
import org.apache.atlas.omrs.metadatacollection.properties.typedefs.TypeDefSummary;
+import org.apache.atlas.omrs.rest.repositoryconnector.OMRSRESTRepositoryConnectorProvider;
import org.apache.atlas.omrs.topicconnectors.kafka.KafkaOMRSTopicProvider;
import java.util.ArrayList;
+import java.util.List;
import java.util.UUID;
/**
- * OMRSConfigurationFactory sets up default configuration for the OMRS components and manages the changes made
- * by the server administrator.
+ * OMRSConfigurationFactory sets up default configuration for the OMRS components. It is used by the OMAG server
+ * while it manages the changes made to the server configuration by the server administrator. The aim is to
+ * build up the RepositoryServicesConfig object that is used to initialize the OMRSOperationalServices.
*/
public class OMRSConfigurationFactory
{
/*
* Default property fillers
*/
- private static final String defaultEnterpriseMetadataCollectionName = "Enterprise Metadata Collection";
+ private static final String defaultEnterpriseMetadataCollectionName = " Enterprise Metadata Collection";
+
+ private static final String defaultTopicRootName = "omag/omrs/";
+ private static final String defaultTopicLeafName = "/OMRSTopic";
+
+ private static final String defaultEnterpriseTopicConnectorRootName = "enterprise/";
+ private static final String defaultCohortTopicConnectorRootName = "cohort/";
+
+ private static final String defaultCohortName = "defaultCohort";
+
+ private static final String defaultOpenMetadataArchiveFileName = "OpenMetadataTypes.json";
+
+ /**
+ * Default constructor
+ */
+ public OMRSConfigurationFactory()
+ {
+ }
+
+
+ /**
+ * Return the connection for the default audit log.
+ * By default, the Audit log is stored in a directory called localServerName.auditlog.
+ *
+ * @param localServerName - name of the local server
+ * @return OCF Connection used to create the file-based audit logger
+ */
+ private Connection getDefaultAuditLogConnection(String localServerName)
+ {
+ final String endpointGUID = "836efeae-ab34-4425-89f0-6adf2faa1f2e";
+ final String connectorTypeGUID = "f8a24f09-9183-4d5c-8408-aa1c8852a7d6";
+ final String connectionGUID = "5390bf3e-6b38-4eda-b34a-de55ac4252a7";
+
+ final String endpointDescription = "OMRS default audit log endpoint.";
+
+ String endpointAddress = localServerName + ".auditlog";
+ String endpointName = "DefaultAuditLog.Endpoint." + endpointAddress;
- private static final String defaultTopicRootName = "omag";
- private static final String defaultTopicLeafName = "OMRSTopic";
+ Endpoint endpoint = new Endpoint();
- private static final String defaultTopicConnectorLeafName = "OMRS Topic Connector";
- private static final String defaultEnterpriseTopicConnectorRootName = "Enterprise";
+ endpoint.setType(this.getEndpointType());
+ endpoint.setGUID(endpointGUID);
+ endpoint.setQualifiedName(endpointName);
+ endpoint.setDisplayName(endpointName);
+ endpoint.setDescription(endpointDescription);
+ endpoint.setAddress(endpointAddress);
- private static final String defaultTopicConnectorName = "OMRS Kafka Topic Connector";
- private static final String defaultTopicConnectorDescription = "Kafka Topic used to exchange event between members of an open metadata repository cluster.";
- private static final String defaultTopicConnectorProviderClassName = KafkaOMRSTopicProvider.class.getName();
+ final String connectorTypeDescription = "OMRS default audit log connector type.";
+ final String connectorTypeJavaClassName = FileBasedAuditLogStoreProvider.class.getName();
- private static final String defaultCohortName = "defaultCohort";
+ String connectorTypeName = "DefaultAuditLog.ConnectorType." + localServerName;
- private static final String defaultRegistryStoreFQName = "OMRS Cohort Registry Store: cohort.registry";
- private static final String defaultRegistryStoreDisplayName = "Cohort Registry Store";
- private static final String defaultRegistryStoreDescription = "File-based Store use by the cohort registry to store information about the members of the open metadata repository cluster.";
- private static final String defaultRegistryStoreAddress = "cohort.registry";
- private static final String defaultRegistryStoreProviderClassName = FileBasedRegistryStoreProvider.class.getName();
+ ConnectorType connectorType = new ConnectorType();
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+ final String connectionDescription = "OMRS default audit log connection.";
- private String localServerName = null;
- private String localServerType = null;
- private String localServerURL = null;
- private String localOrganizationName = null;
- private RepositoryServicesConfig repositoryServicesConfig = null;
+ String connectionName = "DefaultAuditLog.Connection." + localServerName;
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setEndpoint(endpoint);
+ connection.setConnectorType(connectorType);
+
+ return connection;
+ }
/**
- * Constructor used when the server is being configured. Any parameter may be null.
+ * Return the connection for the default audit log.
+ * By default, the open metadata is stored in a file called localServerName.auditlog.
*
- * @param localServerName - name of the local server
- * @param localServerType - type of the local server
- * @param localServerURL - URL of the local server
- * @param localOrganizationName - name of the organization that owns the local server
+ * @return OCF Connection used to create the file-based open metadata archive
*/
- public OMRSConfigurationFactory(String localServerName,
- String localServerType,
- String localServerURL,
- String localOrganizationName)
+ public Connection getOpenMetadataTypesConnection()
{
- this.localServerName = localServerName;
- this.localServerType = localServerType;
- this.localServerURL = localServerURL;
- this.localOrganizationName = localOrganizationName;
+ final String endpointGUID = "45877b9c-9192-44ba-a2b7-6817bc753969";
+ final String connectorTypeGUID = "86f52a17-5d3c-47fd-9cac-0b5a45d150a9";
+ final String connectionGUID = "447bbb33-84f9-4a56-a712-addeebdcd764";
+
+ final String endpointDescription = "Open metadata types archive endpoint.";
+
+ String endpointAddress = defaultOpenMetadataArchiveFileName;
+ String endpointName = "OpenMetadataTypes.Endpoint" + endpointAddress;
+
+ Endpoint endpoint = new Endpoint();
+
+ endpoint.setType(this.getEndpointType());
+ endpoint.setGUID(endpointGUID);
+ endpoint.setQualifiedName(endpointName);
+ endpoint.setDisplayName(endpointName);
+ endpoint.setDescription(endpointDescription);
+ endpoint.setAddress(endpointAddress);
+
+ final String connectorTypeDescription = "Open metadata types archive connector type.";
+ final String connectorTypeJavaClassName = FileBasedOpenMetadataArchiveStoreProvider.class.getName();
+
+ String connectorTypeName = "OpenMetadataTypes.ConnectorType";
+
+ ConnectorType connectorType = new ConnectorType();
+
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+
+ final String connectionDescription = "Open metadata types archive connection.";
+
+ String connectionName = "OpenMetadataTypes.Connection";
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setEndpoint(endpoint);
+ connection.setConnectorType(connectorType);
+
+ return connection;
}
- public Connection getGenericConnection()
+
+ /**
+ * Return the default local repository's local connection. This is set to null which means use the remote
+ * connection.
+ *
+ * @return null Connection object
+ */
+ private Connection getDefaultLocalRepositoryLocalConnection()
{
return null;
}
- public Connection getDefaultAuditLogConnection()
+
+ /**
+ * Return the local graph repository's connection. This is using the LocalAtlasOMRSRepositoryConnector.
+ *
+ * @param localServerName - name of the local server
+ * @return Connection object
+ */
+ private Connection getLocalGraphRepositoryLocalConnection(String localServerName)
{
- return null;
+ final String connectorTypeGUID = "18530415-44a2-4bd0-95bb-8efd333e53fb";
+ final String connectionGUID = "3f1fd4fc-90f9-436a-8e2c-2120d590f5e4";
+
+ final String connectorTypeDescription = "OMRS default graph local repository connector type.";
+ final String connectorTypeJavaClassName = LocalAtlasOMRSRepositoryConnectorProvider.class.getName();
+
+ String connectorTypeName = "DefaultLocalGraphRepository.ConnectorType." + localServerName;
+
+ ConnectorType connectorType = new ConnectorType();
+
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+
+
+ final String connectionDescription = "OMRS default local graph repository connection.";
+
+ String connectionName = "DefaultLocalGraphRepository.Connection." + localServerName;
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setConnectorType(connectorType);
+
+ return connection;
}
- public Connection getDefaultOpenMetadataTypesArchiveConnection()
+
+ /**
+ * Return the in-memory local repository connection. This is using the InMemoryOMRSRepositoryConnector.
+ *
+ * @param localServerName - name of the local server
+ * @return Connection object
+ */
+ private Connection getInMemoryLocalRepositoryLocalConnection(String localServerName)
{
- return null;
+ final String connectorTypeGUID = "21422eb9-c6c1-4071-b96b-0572c9680260";
+ final String connectionGUID = "6a3c07b0-0e04-42dc-bcc6-392609bf1d02";
+
+ final String connectorTypeDescription = "OMRS default in memory local repository connector type.";
+ final String connectorTypeJavaClassName = InMemoryOMRSRepositoryConnectorProvider.class.getName();
+
+ String connectorTypeName = "DefaultInMemoryRepository.ConnectorType." + localServerName;
+
+ ConnectorType connectorType = new ConnectorType();
+
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+
+
+ final String connectionDescription = "OMRS default in memory local repository connection.";
+
+ String connectionName = "DefaultInMemoryRepository.Connection." + localServerName;
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setConnectorType(connectorType);
+
+ return connection;
}
- private Connection getGenericArchiveConnection()
+
+ /**
+ * Return the Connection for this server's OMRS Repository REST API. If the localServerURL is
+ * something like localhost:8080/omag/localServerName and the REST API URL would be
+ * localhost:8080/omag/localServerName/omrs/metadatacollection.
+ *
+ * @param localServerName - name of the local server
+ * @param localServerURL - root of the local server's URL
+ * @return Connection object
+ */
+ private Connection getDefaultLocalRepositoryRemoteConnection(String localServerName,
+ String localServerURL)
{
- return null;
+ final String endpointGUID = "cee85898-43aa-4af5-9bbd-2bed809d1acb";
+ final String connectorTypeGUID = "64e67923-8190-45ea-8f96-39320d638c02";
+ final String connectionGUID = "858be98b-49d2-4ccf-9b23-01085a5f473f";
+
+ final String endpointDescription = "OMRS default repository REST API endpoint.";
+
+ String endpointAddress = localServerURL + "/omag/omrs/";
+ String endpointName = "DefaultRepositoryRESTAPI.Endpoint." + localServerName;
+
+ Endpoint endpoint = new Endpoint();
+
+ endpoint.setType(this.getEndpointType());
+ endpoint.setGUID(endpointGUID);
+ endpoint.setQualifiedName(endpointName);
+ endpoint.setDisplayName(endpointName);
+ endpoint.setDescription(endpointDescription);
+ endpoint.setAddress(endpointAddress);
+
+ final String connectorTypeDescription = "OMRS default repository REST API connector type.";
+ final String connectorTypeJavaClassName = OMRSRESTRepositoryConnectorProvider.class.getName();
+
+ String connectorTypeName = "DefaultRepositoryRESTAPI.ConnectorType." + localServerName;
+
+ ConnectorType connectorType = new ConnectorType();
+
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+
+
+ final String connectionDescription = "OMRS default repository REST API connection.";
+
+ String connectionName = "DefaultRepositoryRESTAPI.Connection." + localServerName;
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setEndpoint(endpoint);
+ connection.setConnectorType(connectorType);
+
+ return connection;
}
- private Connection getGenericRepositoryConnection()
+
+ /**
+ * Return the default local repository event mapper. This is null since the use of, or need for, the event mapper
+ * is determined by the type of local repository.
+ *
+ * @return null Connection object
+ */
+ private Connection getDefaultEventMapperConnection()
{
return null;
}
- private Connection getDefaultLocalRepositoryLocalConnection()
+
+ /**
+ * Return the default connection for the enterprise OMRS topic. This uses a Kafka topic called
+ * omag/omrs/enterprise/localServerName/OMRSTopic.
+ *
+ * @param localServerName - name of local server
+ * @return Connection object
+ */
+ private Connection getDefaultEnterpriseOMRSTopicConnection(String localServerName)
{
- return null;
+ final String endpointGUID = "e0d88035-8522-42bc-b57f-06df05f15825";
+ final String connectorTypeGUID = "6536cb46-61f0-4f2d-abb4-2dadede30520";
+ final String connectionGUID = "2084ee90-717b-49a1-938e-8f9d49567b8e";
+
+ final String endpointDescription = "OMRS default enterprise topic endpoint.";
+
+ String endpointAddress = defaultTopicRootName + defaultEnterpriseTopicConnectorRootName + localServerName + defaultTopicLeafName;
+ String endpointName = "DefaultEnterpriseTopic.Endpoint." + endpointAddress;
+
+ Endpoint endpoint = new Endpoint();
+
+ endpoint.setType(this.getEndpointType());
+ endpoint.setGUID(endpointGUID);
+ endpoint.setQualifiedName(endpointName);
+ endpoint.setDisplayName(endpointName);
+ endpoint.setDescription(endpointDescription);
+ endpoint.setAddress(endpointAddress);
+
+
+ final String connectorTypeDescription = "OMRS default enterprise connector type.";
+ final String connectorTypeJavaClassName = KafkaOMRSTopicProvider.class.getName();
+
+ String connectorTypeName = "DefaultEnterpriseTopic.ConnectorType." + localServerName;
+
+ ConnectorType connectorType = new ConnectorType();
+
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+
+
+ final String connectionDescription = "OMRS default enterprise topic connection.";
+
+ String connectionName = "DefaultEnterpriseTopic.Connection." + localServerName;
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setEndpoint(endpoint);
+ connection.setConnectorType(connectorType);
+
+ return connection;
}
- private Connection getAtlasLocalRepositoryLocalConnection()
+
+ /**
+ * Return the connection for the OMRS topic for the named cohort.
+ *
+ * @param cohortName - name of the cohort
+ * @return Connection object
+ */
+ private Connection getDefaultCohortOMRSTopicConnection(String cohortName)
{
- return null;
+ final String endpointGUID = "dca783a1-d5f9-44a8-b838-4de4d016303d";
+ final String connectorTypeGUID = "32843dd8-2597-4296-831c-674af0d8b837";
+ final String connectionGUID = "023bb1f3-03dd-47ae-b3bc-dce62e9c11cb";
+
+ final String endpointDescription = "OMRS default cohort topic endpoint.";
+
+ String endpointAddress = defaultTopicRootName + defaultCohortTopicConnectorRootName + cohortName + defaultTopicLeafName;
+ String endpointName = "DefaultCohortTopic.Endpoint." + endpointAddress;
+
+ Endpoint endpoint = new Endpoint();
+
+ endpoint.setType(this.getEndpointType());
+ endpoint.setGUID(endpointGUID);
+ endpoint.setQualifiedName(endpointName);
+ endpoint.setDisplayName(endpointName);
+ endpoint.setDescription(endpointDescription);
+ endpoint.setAddress(endpointAddress);
+
+
+ final String connectorTypeDescription = "OMRS default cohort topic connector type.";
+ final String connectorTypeJavaClassName = KafkaOMRSTopicProvider.class.getName();
+
+ String connectorTypeName = "DefaultCohortTopic.ConnectorType." + cohortName;
+
+ ConnectorType connectorType = new ConnectorType();
+
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+
+
+ final String connectionDescription = "OMRS default cohort topic connection.";
+
+ String connectionName = "DefaultCohortTopic.Connection." + cohortName;
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setEndpoint(endpoint);
+ connection.setConnectorType(connectorType);
+
+ return connection;
}
- private Connection getDefaultLocalRepositoryRemoteConnection(String localServerURL)
+
+ /**
+ * Return the connection to the default registry store called localServerName.cohortName.registrystore.
+ *
+ * @param localServerName - name of the local server
+ * @param cohortName - name of the cohort
+ * @return Connection object
+ */
+ private Connection getDefaultCohortRegistryConnection(String localServerName, String cohortName)
{
- return null;
+ final String endpointGUID = "8bf8f5fa-b5d8-40e1-a00e-e4a0c59fd6c0";
+ final String connectorTypeGUID = "2e1556a3-908f-4303-812d-d81b48b19bab";
+ final String connectionGUID = "b9af734f-f005-4085-9975-bf46c67a099a";
+
+ final String endpointDescription = "OMRS default cohort registry endpoint.";
+
+ String endpointAddress = localServerName + "." + cohortName + ".registrystore";
+ String endpointName = "DefaultCohortRegistry.Endpoint." + endpointAddress;
+
+ Endpoint endpoint = new Endpoint();
+
+ endpoint.setType(this.getEndpointType());
+ endpoint.setGUID(endpointGUID);
+ endpoint.setQualifiedName(endpointName);
+ endpoint.setDisplayName(endpointName);
+ endpoint.setDescription(endpointDescription);
+ endpoint.setAddress(endpointAddress);
+
+
+ final String connectorTypeDescription = "OMRS default cohort registry connector type.";
+ final String connectorTypeJavaClassName = FileBasedRegistryStoreProvider.class.getName();
+
+ String connectorTypeName = "DefaultCohortRegistry.ConnectorType." + localServerName + "." + cohortName;
+
+ ConnectorType connectorType = new ConnectorType();
+
+ connectorType.setType(this.getConnectorTypeType());
+ connectorType.setGUID(connectorTypeGUID);
+ connectorType.setQualifiedName(connectorTypeName);
+ connectorType.setDisplayName(connectorTypeName);
+ connectorType.setDescription(connectorTypeDescription);
+ connectorType.setConnectorProviderClassName(connectorTypeJavaClassName);
+
+
+ final String connectionDescription = "OMRS default cohort registry connection.";
+
+ String connectionName = "DefaultCohortRegistry.Connection." + localServerName + "." + cohortName;
+
+ Connection connection = new Connection();
+
+ connection.setType(this.getConnectionType());
+ connection.setGUID(connectionGUID);
+ connection.setQualifiedName(connectionName);
+ connection.setDisplayName(connectionName);
+ connection.setDescription(connectionDescription);
+ connection.setEndpoint(endpoint);
+ connection.setConnectorType(connectorType);
+
+ return connection;
}
- private Connection getDefaultEventMapperConnection()
+
+ /**
+ * Return the protocol level to use for communications with local open metadata access services through the open metadata
+ * enterprise repository services.
+ *
+ * @return protocol version
+ */
+ private OpenMetadataEventProtocolVersion getDefaultEnterpriseOMRSTopicProtocolVersion()
{
- return null;
+ return OpenMetadataEventProtocolVersion.V1;
}
- public Connection getGenericEventMapperConnection()
+
+ /**
+ * Return the protocol level to use for communications with other members of the open metadata repository cohort.
+ *
+ * @return protocol version
+ */
+ private OpenMetadataEventProtocolVersion getDefaultCohortOMRSTopicProtocolVersion()
{
- return null;
+ return OpenMetadataEventProtocolVersion.V1;
}
- private Connection getDefaultEnterpriseOMRSTopicConnection() { return null; }
- private Connection getDefaultCohortOMRSTopicConnection () { return null; }
+ /**
+ * Return the exchange rule set so that events for all local repository changes are sent.
+ *
+ * @return exchange rule
+ */
+ private OpenMetadataExchangeRule getDefaultEventsToSendRule()
+ {
+ return OpenMetadataExchangeRule.ALL;
+ }
+
- private Connection getDefaultCohortRegistryConnection ()
+ /**
+ * Return the default list of types to send as a null because the exchange rule above is set to ALL.
+ *
+ * @return null array list
+ */
+ private ArrayList<TypeDefSummary> getDefaultSelectedTypesToSend()
{
return null;
}
- private OpenMetadataEventProtocolVersion getDefaultEnterpriseOMRSTopicProtocolVersion() { return OpenMetadataEventProtocolVersion.V1; }
- private OpenMetadataEventProtocolVersion getDefaultCohortOMRSTopicProtocolVersion() { return OpenMetadataEventProtocolVersion.V1; }
-
- private OpenMetadataExchangeRule getDefaultEventsToSendRule()
+ /**
+ * Return the exchange rule set so that all received events are saved.
+ *
+ * @return exchange rule
+ */
+ private OpenMetadataExchangeRule getDefaultEventsToSaveRule()
{
return OpenMetadataExchangeRule.ALL;
}
- private ArrayList<TypeDefSummary> getDefaultSelectedTypesToSend() { return null; }
- private OpenMetadataExchangeRule getDefaultEventsToSaveRule()
+ /**
+ * Return the default list of types to save as a null because the exchange rule above is set to ALL.
+ *
+ * @return null array list
+ */
+ private ArrayList<TypeDefSummary> getDefaultSelectedTypesToSave()
{
- return OpenMetadataExchangeRule.ALL;
+ return null;
}
- private ArrayList<TypeDefSummary> getDefaultSelectedTypesToSave() { return null; }
+ /**
+ * Return the exchange rule set so that all incoming events are processed.
+ *
+ * @return exchange rule
+ */
private OpenMetadataExchangeRule getDefaultEventsToProcessRule()
{
return OpenMetadataExchangeRule.ALL;
}
- private ArrayList<TypeDefSummary> getDefaultSelectedTypesToProcess() { return null; }
- private ArrayList<Connection> getDefaultOpenMetadataArchiveList()
+ /**
+ * Return the default list of types to process as a null because the exchange rule above is set to ALL.
+ *
+ * @return null array list
+ */
+ private ArrayList<TypeDefSummary> getDefaultSelectedTypesToProcess()
{
- ArrayList<Connection> openMetadataArchiveList = new ArrayList<>();
-
- openMetadataArchiveList.add(this.getDefaultOpenMetadataTypesArchiveConnection());
-
- return openMetadataArchiveList;
+ return null;
}
- public LocalRepositoryConfig getDefaultLocalRepositoryConfig(String localServerURL)
+
+ /**
+ * Returns the basic configuration for a local repository.
+ *
+ * @param localServerName - name of the local server
+ * @param localServerURL - URL root of local server used for REST calls
+ * @return LocalRepositoryConfig object
+ */
+ private LocalRepositoryConfig getDefaultLocalRepositoryConfig(String localServerName,
+ String localServerURL)
{
- LocalRepositoryConfig localRepositoryConfig = new LocalRepositoryConfig();
+ LocalRepositoryConfig localRepositoryConfig = new LocalRepositoryConfig();
localRepositoryConfig.setMetadataCollectionId(UUID.randomUUID().toString());
localRepositoryConfig.setLocalRepositoryLocalConnection(this.getDefaultLocalRepositoryLocalConnection());
- localRepositoryConfig.setLocalRepositoryRemoteConnection(this.getDefaultLocalRepositoryRemoteConnection(localServerURL));
+ localRepositoryConfig.setLocalRepositoryRemoteConnection(this.getDefaultLocalRepositoryRemoteConnection(
+ localServerName,
+ localServerURL));
localRepositoryConfig.setEventsToSaveRule(this.getDefaultEventsToSaveRule());
localRepositoryConfig.setSelectedTypesToSave(this.getDefaultSelectedTypesToSave());
localRepositoryConfig.setEventsToSendRule(this.getDefaultEventsToSendRule());
@@ -193,13 +656,75 @@ public class OMRSConfigurationFactory
return localRepositoryConfig;
}
- public EnterpriseAccessConfig getDefaultEnterpriseAccessConfig()
+
+ /**
+ * Return the configuration for an in-memory local repository.
+ *
+ * @param localServerName - name of the local server
+ * @param localServerURL - URL root of local server used for REST calls
+ * @return LocalRepositoryConfig object
+ */
+ public LocalRepositoryConfig getInMemoryLocalRepositoryConfig(String localServerName, String localServerURL)
+ {
+ LocalRepositoryConfig localRepositoryConfig = this.getDefaultLocalRepositoryConfig(localServerName,
+ localServerURL);
+
+ localRepositoryConfig.setLocalRepositoryLocalConnection(this.getInMemoryLocalRepositoryLocalConnection(
+ localServerName));
+
+ return localRepositoryConfig;
+ }
+
+
+ /**
+ * Return the configuration for a local repository that is using the built-in graph repository.
+ *
+ * @param localServerName - name of local server
+ * @param localServerURL - URL root of local server used for REST calls
+ * @return LocalRepositoryConfig object
+ */
+ public LocalRepositoryConfig getLocalGraphLocalRepositoryConfig(String localServerName, String localServerURL)
+ {
+ LocalRepositoryConfig localRepositoryConfig = this.getDefaultLocalRepositoryConfig(localServerName,
+ localServerURL);
+
+ localRepositoryConfig.setLocalRepositoryLocalConnection(this.getLocalGraphRepositoryLocalConnection(
+ localServerName));
+
+ return localRepositoryConfig;
+ }
+
+
+ /**
+ * Return the local repository configuration for a repository proxy.
+ *
+ * @return LocalRepositoryConfig object
+ */
+ public LocalRepositoryConfig getRepositoryProxyLocalRepositoryConfig(String localServerName, String localServerURL)
+ {
+ LocalRepositoryConfig localRepositoryConfig = this.getDefaultLocalRepositoryConfig(localServerName,
+ localServerURL);
+
+ localRepositoryConfig.setLocalRepositoryLocalConnection(null);
+
+ return localRepositoryConfig;
+ }
+
+
+ /**
+ * Return the default settings for the enterprise repository services' configuration.
+ *
+ * @param localServerName - name of the local server
+ * @return EnterpriseAccessConfig parameters
+ */
+ public EnterpriseAccessConfig getDefaultEnterpriseAccessConfig(String localServerName)
{
- EnterpriseAccessConfig enterpriseAccessConfig = new EnterpriseAccessConfig();
+ EnterpriseAccessConfig enterpriseAccessConfig = new EnterpriseAccessConfig();
enterpriseAccessConfig.setEnterpriseMetadataCollectionId(UUID.randomUUID().toString());
- enterpriseAccessConfig.setEnterpriseMetadataCollectionName(defaultEnterpriseMetadataCollectionName);
- enterpriseAccessConfig.setEnterpriseOMRSTopicConnection(this.getDefaultEnterpriseOMRSTopicConnection());
+ enterpriseAccessConfig.setEnterpriseMetadataCollectionName(localServerName + defaultEnterpriseMetadataCollectionName);
+ enterpriseAccessConfig.setEnterpriseOMRSTopicConnection(this.getDefaultEnterpriseOMRSTopicConnection(
+ localServerName));
enterpriseAccessConfig.setEnterpriseOMRSTopicProtocolVersion(this.getDefaultEnterpriseOMRSTopicProtocolVersion());
return enterpriseAccessConfig;
@@ -209,15 +734,23 @@ public class OMRSConfigurationFactory
/**
* Return a CohortConfig object that is pre-configured with default values.
*
+ * @param localServerName - name of the local server
+ * @param cohortName - name of the cohort
* @return default values in a CohortConfig object
*/
- public CohortConfig getDefaultCohortConfig()
+ public CohortConfig getDefaultCohortConfig(String localServerName, String cohortName)
{
- CohortConfig cohortConfig = new CohortConfig();
+ CohortConfig cohortConfig = new CohortConfig();
+ String newCohortName = defaultCohortName;
+
+ if (cohortName != null)
+ {
+ newCohortName = cohortName;
+ }
- cohortConfig.setCohortName(defaultCohortName);
- cohortConfig.setCohortRegistryConnection(this.getDefaultCohortRegistryConnection());
- cohortConfig.setCohortOMRSTopicConnection(this.getDefaultCohortOMRSTopicConnection());
+ cohortConfig.setCohortName(newCohortName);
+ cohortConfig.setCohortRegistryConnection(this.getDefaultCohortRegistryConnection(localServerName, newCohortName));
+ cohortConfig.setCohortOMRSTopicConnection(this.getDefaultCohortOMRSTopicConnection(newCohortName));
cohortConfig.setCohortOMRSTopicProtocolVersion(this.getDefaultCohortOMRSTopicProtocolVersion());
cohortConfig.setEventsToProcessRule(this.getDefaultEventsToProcessRule());
cohortConfig.setSelectedTypesToProcess(this.getDefaultSelectedTypesToProcess());
@@ -225,4 +758,110 @@ public class OMRSConfigurationFactory
return cohortConfig;
}
+
+ /**
+ * Returns a repository services config with the audit log set up.
+ *
+ * @param localServerName - name of the local server
+ * @return minimally configured repository services config
+ */
+ public RepositoryServicesConfig getDefaultRepositoryServicesConfig(String localServerName)
+ {
+ RepositoryServicesConfig repositoryServicesConfig = new RepositoryServicesConfig();
+
+ List<Connection> auditLogStoreConnections = new ArrayList<>();
+
+ auditLogStoreConnections.add(this.getDefaultAuditLogConnection(localServerName));
+
+ repositoryServicesConfig.setAuditLogConnections(auditLogStoreConnections);
+
+ return repositoryServicesConfig;
+ }
+
+
+ /**
+ * Return the standard type for an endpoint.
+ *
+ * @return ElementType object
+ */
+ public ElementType getEndpointType()
+ {
+ final String elementTypeId = "dbc20663-d705-4ff0-8424-80c262c6b8e7";
+ final String elementTypeName = "Endpoint";
+ final long elementTypeVersion = 1;
+ final String elementTypeDescription = "Description of the network address and related information needed to call a software service.";
+ final String elementAccessServiceURL = null;
+ final ElementOrigin elementOrigin = ElementOrigin.LOCAL_COHORT;
+ final String elementHomeMetadataCollectionId = null;
+
+ ElementType elementType = new ElementType();
+
+ elementType.setElementTypeId(elementTypeId);
+ elementType.setElementTypeName(elementTypeName);
+ elementType.setElementTypeVersion(elementTypeVersion);
+ elementType.setElementTypeDescription(elementTypeDescription);
+ elementType.setElementAccessServiceURL(elementAccessServiceURL);
+ elementType.setElementOrigin(elementOrigin);
+ elementType.setElementHomeMetadataCollectionId(elementHomeMetadataCollectionId);
+
+ return elementType;
+ }
+
+
+ /**
+ * Return the standard type for a connector type.
+ *
+ * @return ElementType object
+ */
+ public ElementType getConnectorTypeType()
+ {
+ final String elementTypeId = "954421eb-33a6-462d-a8ca-b5709a1bd0d4";
+ final String elementTypeName = "ConnectorType";
+ final long elementTypeVersion = 1;
+ final String elementTypeDescription = "A set of properties describing a type of connector.";
+ final String elementAccessServiceURL = null;
+ final ElementOrigin elementOrigin = ElementOrigin.LOCAL_COHORT;
+ final String elementHomeMetadataCollectionId = null;
+
+ ElementType elementType = new ElementType();
+
+ elementType.setElementTypeId(elementTypeId);
+ elementType.setElementTypeName(elementTypeName);
+ elementType.setElementTypeVersion(elementTypeVersion);
+ elementType.setElementTypeDescription(elementTypeDescription);
+ elementType.setElementAccessServiceURL(elementAccessServiceURL);
+ elementType.setElementOrigin(elementOrigin);
+ elementType.setElementHomeMetadataCollectionId(elementHomeMetadataCollectionId);
+
+ return elementType;
+ }
+
+
+ /**
+ * Return the standard type for a connection type.
+ *
+ * @return ElementType object
+ */
+ public ElementType getConnectionType()
+ {
+ final String elementTypeId = "114e9f8f-5ff3-4c32-bd37-a7eb42712253";
+ final String elementTypeName = "Connection";
+ final long elementTypeVersion = 1;
+ final String elementTypeDescription = "A set of properties to identify and configure a connector instance.";
+ final String elementAccessServiceURL = null;
+ final ElementOrigin elementOrigin = ElementOrigin.LOCAL_COHORT;
+ final String elementHomeMetadataCollectionId = null;
+
+ ElementType elementType = new ElementType();
+
+ elementType.setElementTypeId(elementTypeId);
+ elementType.setElementTypeName(elementTypeName);
+ elementType.setElementTypeVersion(elementTypeVersion);
+ elementType.setElementTypeDescription(elementTypeDescription);
+ elementType.setElementAccessServiceURL(elementAccessServiceURL);
+ elementType.setElementOrigin(elementOrigin);
+ elementType.setElementHomeMetadataCollectionId(elementHomeMetadataCollectionId);
+
+ return elementType;
+ }
}