Package org.odpi.openmetadata.accessservices.assetmanager.client

Class ConnectionExchangeClient

    • Constructor Detail

      • ConnectionExchangeClient

        public ConnectionExchangeClient​(String serverName,
                                String serverPlatformURLRoot,
                                AuditLog auditLog)
                         throws InvalidParameterException
        Create a new client with no authentication embedded in the HTTP request.
        Parameters:
        serverName - name of the server to connect to
        serverPlatformURLRoot - the network address of the server running the OMAS REST servers
        auditLog - logging destination
        Throws:
        InvalidParameterException - there is a problem creating the client-side components to issue any REST API calls.

      • ConnectionExchangeClient

        public ConnectionExchangeClient​(String serverName,
                                String serverPlatformURLRoot)
                         throws InvalidParameterException
        Create a new client with no authentication embedded in the HTTP request.
        Parameters:
        serverName - name of the server to connect to
        serverPlatformURLRoot - the network address of the server running the OMAS REST servers
        Throws:
        InvalidParameterException - there is a problem creating the client-side components to issue any REST API calls.

      • ConnectionExchangeClient

        public ConnectionExchangeClient​(String serverName,
                                String serverPlatformURLRoot,
                                String userId,
                                String password,
                                AuditLog auditLog)
                         throws InvalidParameterException
        Create a new client that passes userId and password in each HTTP request. This is the userId/password of the calling server. The end user's userId is sent on each request.
        Parameters:
        serverName - name of the server to connect to
        serverPlatformURLRoot - the network address of the server running the OMAS REST servers
        userId - caller's userId embedded in all HTTP requests
        password - caller's userId embedded in all HTTP requests
        auditLog - logging destination
        Throws:
        InvalidParameterException - there is a problem creating the client-side components to issue any REST API calls.

      • ConnectionExchangeClient

        public ConnectionExchangeClient​(String serverName,
                                String serverPlatformURLRoot,
                                AssetManagerRESTClient restClient,
                                int maxPageSize,
                                AuditLog auditLog)
                         throws InvalidParameterException
        Create a new client that is going to be used in an OMAG Server.
        Parameters:
        serverName - name of the server to connect to
        serverPlatformURLRoot - the network address of the server running the OMAS REST servers
        restClient - client that issues the REST API calls
        maxPageSize - maximum number of results supported by this server
        auditLog - logging destination
        Throws:
        InvalidParameterException - there is a problem creating the client-side components to issue any REST API calls.

      • ConnectionExchangeClient

        public ConnectionExchangeClient​(String serverName,
                                String serverPlatformURLRoot,
                                String userId,
                                String password)
                         throws InvalidParameterException
        Create a new client that passes userId and password in each HTTP request. This is the userId/password of the calling server. The end user's userId is sent on each request.
        Parameters:
        serverName - name of the server to connect to
        serverPlatformURLRoot - the network address of the server running the OMAS REST servers
        userId - caller's userId embedded in all HTTP requests
        password - caller's userId embedded in all HTTP requests
        Throws:
        InvalidParameterException - there is a problem creating the client-side components to issue any REST API calls.

    • Method Detail

      • createConnectionFromTemplate

        public String createConnectionFromTemplate​(String userId,
                                           String assetManagerGUID,
                                           String assetManagerName,
                                           boolean assetManagerIsHome,
                                           String templateGUID,
                                           ExternalIdentifierProperties externalIdentifierProperties,
                                           TemplateProperties templateProperties)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException
        Create a new metadata element to represent a connection using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new connection.
        Specified by:
        createConnectionFromTemplate in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetManagerIsHome - ensure that only the asset manager can update this connection
        externalIdentifierProperties - optional properties used to define an external identifier
        templateGUID - unique identifier of the metadata element to copy
        templateProperties - properties that override the template
        Returns:
        unique identifier of the new metadata element
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • updateConnection

        public void updateConnection​(String userId,
                             String assetManagerGUID,
                             String assetManagerName,
                             String connectionGUID,
                             String connectionExternalIdentifier,
                             boolean isMergeUpdate,
                             ConnectionProperties connectionProperties,
                             Date effectiveTime,
                             boolean forLineage,
                             boolean forDuplicateProcessing)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
        Update the metadata element representing an asset.
        Specified by:
        updateConnection in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectionGUID - unique identifier of the metadata element to update
        connectionExternalIdentifier - unique identifier of the connection in the external asset manager
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        connectionProperties - new properties for this element
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • setupConnectorType

        public void setupConnectorType​(String userId,
                               String assetManagerGUID,
                               String assetManagerName,
                               boolean assetManagerIsHome,
                               String connectionGUID,
                               String connectorTypeGUID,
                               Date effectiveFrom,
                               Date effectiveTo,
                               Date effectiveTime,
                               boolean forLineage,
                               boolean forDuplicateProcessing)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
        Create a relationship between a connection and a connector type.
        Specified by:
        setupConnectorType in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        connectionGUID - unique identifier of the connection in the external asset manager
        connectorTypeGUID - unique identifier of the connector type in the external asset manager
        effectiveFrom - the date when this element is active - null for active now
        effectiveTo - the date when this element becomes inactive - null for active until deleted
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • clearConnectorType

        public void clearConnectorType​(String userId,
                               String assetManagerGUID,
                               String assetManagerName,
                               String connectionGUID,
                               String connectorTypeGUID,
                               Date effectiveTime,
                               boolean forLineage,
                               boolean forDuplicateProcessing)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException
        Remove a relationship between a connection and a connector type.
        Specified by:
        clearConnectorType in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectionGUID - unique identifier of the connection in the external asset manager
        connectorTypeGUID - unique identifier of the connector type in the external asset manager
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • setupEndpoint

        public void setupEndpoint​(String userId,
                          String assetManagerGUID,
                          String assetManagerName,
                          boolean assetManagerIsHome,
                          String connectionGUID,
                          String endpointGUID,
                          Date effectiveFrom,
                          Date effectiveTo,
                          Date effectiveTime,
                          boolean forLineage,
                          boolean forDuplicateProcessing)
                   throws InvalidParameterException,
                          UserNotAuthorizedException,
                          PropertyServerException
        Create a relationship between a connection and an endpoint.
        Specified by:
        setupEndpoint in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        connectionGUID - unique identifier of the connection in the external asset manager
        endpointGUID - unique identifier of the endpoint in the external asset manager
        effectiveFrom - the date when this element is active - null for active now
        effectiveTo - the date when this element becomes inactive - null for active until deleted
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • clearEndpoint

        public void clearEndpoint​(String userId,
                          String assetManagerGUID,
                          String assetManagerName,
                          String connectionGUID,
                          String endpointGUID,
                          Date effectiveTime,
                          boolean forLineage,
                          boolean forDuplicateProcessing)
                   throws InvalidParameterException,
                          UserNotAuthorizedException,
                          PropertyServerException
        Remove a relationship between a connection and an endpoint.
        Specified by:
        clearEndpoint in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectionGUID - unique identifier of the connection in the external asset manager
        endpointGUID - unique identifier of the endpoint in the external asset manager
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • setupEmbeddedConnection

        public void setupEmbeddedConnection​(String userId,
                                    String assetManagerGUID,
                                    String assetManagerName,
                                    boolean assetManagerIsHome,
                                    String connectionGUID,
                                    String embeddedConnectionGUID,
                                    EmbeddedConnectionProperties properties,
                                    Date effectiveTime,
                                    boolean forLineage,
                                    boolean forDuplicateProcessing)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
        Create a relationship between a virtual connection and an embedded connection.
        Specified by:
        setupEmbeddedConnection in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        connectionGUID - unique identifier of the virtual connection in the external asset manager
        embeddedConnectionGUID - unique identifier of the embedded connection in the external asset manager
        properties - properties describing how to use the embedded connection such as: Which order should this connection be processed; What additional properties should be passed to the embedded connector via the configuration properties; What does this connector signify?
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • clearEmbeddedConnection

        public void clearEmbeddedConnection​(String userId,
                                    String assetManagerGUID,
                                    String assetManagerName,
                                    String connectionGUID,
                                    String embeddedConnectionGUID,
                                    Date effectiveTime,
                                    boolean forLineage,
                                    boolean forDuplicateProcessing)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException
        Remove a relationship between a virtual connection and an embedded connection.
        Specified by:
        clearEmbeddedConnection in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectionGUID - unique identifier of the virtual connection in the external asset manager
        embeddedConnectionGUID - unique identifier of the embedded connection in the external asset manager
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • setupAssetConnection

        public void setupAssetConnection​(String userId,
                                 String assetManagerGUID,
                                 String assetManagerName,
                                 boolean assetManagerIsHome,
                                 String assetGUID,
                                 String connectionGUID,
                                 AssetConnectionProperties properties,
                                 Date effectiveTime,
                                 boolean forLineage,
                                 boolean forDuplicateProcessing)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
        Create a relationship between an asset and its connection.
        Specified by:
        setupAssetConnection in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        assetGUID - unique identifier of the asset
        properties - summary of the asset that is stored in the relationship between the asset and the connection.
        connectionGUID - unique identifier of the connection
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • clearAssetConnection

        public void clearAssetConnection​(String userId,
                                 String assetManagerGUID,
                                 String assetManagerName,
                                 String assetGUID,
                                 String connectionGUID,
                                 Date effectiveTime,
                                 boolean forLineage,
                                 boolean forDuplicateProcessing)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException
        Remove a relationship between an asset and its connection.
        Specified by:
        clearAssetConnection in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetGUID - unique identifier of the asset
        connectionGUID - unique identifier of the connection
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • removeConnection

        public void removeConnection​(String userId,
                             String assetManagerGUID,
                             String assetManagerName,
                             String connectionGUID,
                             String connectionExternalIdentifier,
                             Date effectiveTime,
                             boolean forLineage,
                             boolean forDuplicateProcessing)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
        Remove the metadata element representing a connection. This will delete the connection and all anchored elements such as schema and comments.
        Specified by:
        removeConnection in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectionGUID - unique identifier of the metadata element to remove
        connectionExternalIdentifier - unique identifier of the connection in the external asset manager
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • findConnections

        public List<ConnectionElement> findConnections​(String userId,
                                               String assetManagerGUID,
                                               String assetManagerName,
                                               String searchString,
                                               int startFrom,
                                               int pageSize,
                                               Date effectiveTime,
                                               boolean forLineage,
                                               boolean forDuplicateProcessing)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               PropertyServerException
        Retrieve the list of connection metadata elements that contain the search string. The search string is treated as a regular expression.
        Specified by:
        findConnections in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        searchString - string to find in the properties
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getConnectionsByName

        public List<ConnectionElement> getConnectionsByName​(String userId,
                                                    String assetManagerGUID,
                                                    String assetManagerName,
                                                    String name,
                                                    int startFrom,
                                                    int pageSize,
                                                    Date effectiveTime,
                                                    boolean forLineage,
                                                    boolean forDuplicateProcessing)
                                             throws InvalidParameterException,
                                                    UserNotAuthorizedException,
                                                    PropertyServerException
        Retrieve the list of connection metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Specified by:
        getConnectionsByName in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        name - name to search for
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getConnectionsForAssetManager

        public List<ConnectionElement> getConnectionsForAssetManager​(String userId,
                                                             String assetManagerGUID,
                                                             String assetManagerName,
                                                             int startFrom,
                                                             int pageSize,
                                                             Date effectiveTime,
                                                             boolean forLineage,
                                                             boolean forDuplicateProcessing)
                                                      throws InvalidParameterException,
                                                             UserNotAuthorizedException,
                                                             PropertyServerException
        Retrieve the list of connections created on behalf of the named asset manager.
        Specified by:
        getConnectionsForAssetManager in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getConnectionByGUID

        public ConnectionElement getConnectionByGUID​(String userId,
                                             String assetManagerGUID,
                                             String assetManagerName,
                                             String connectionGUID,
                                             Date effectiveTime,
                                             boolean forLineage,
                                             boolean forDuplicateProcessing)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException
        Retrieve the connection metadata element with the supplied unique identifier.
        Specified by:
        getConnectionByGUID in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectionGUID - unique identifier of the requested metadata element
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        matching metadata element
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • createEndpointFromTemplate

        public String createEndpointFromTemplate​(String userId,
                                         String assetManagerGUID,
                                         String assetManagerName,
                                         boolean assetManagerIsHome,
                                         String templateGUID,
                                         ExternalIdentifierProperties externalIdentifierProperties,
                                         TemplateProperties templateProperties)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
        Create a new metadata element to represent a network endpoint using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new endpoint.
        Specified by:
        createEndpointFromTemplate in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetManagerIsHome - ensure that only the asset manager can update this endpoint
        externalIdentifierProperties - optional properties used to define an external identifier
        templateGUID - unique identifier of the metadata element to copy
        templateProperties - properties that override the template
        Returns:
        unique identifier of the new metadata element
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • updateEndpoint

        public void updateEndpoint​(String userId,
                           String assetManagerGUID,
                           String assetManagerName,
                           String endpointGUID,
                           String endpointExternalIdentifier,
                           boolean isMergeUpdate,
                           EndpointProperties endpointProperties,
                           Date effectiveTime,
                           boolean forLineage,
                           boolean forDuplicateProcessing)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
        Update the metadata element representing an asset.
        Specified by:
        updateEndpoint in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        endpointGUID - unique identifier of the metadata element to update
        endpointExternalIdentifier - unique identifier of the endpoint in the external asset manager
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        endpointProperties - new properties for this element
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • removeEndpoint

        public void removeEndpoint​(String userId,
                           String assetManagerGUID,
                           String assetManagerName,
                           String endpointGUID,
                           String endpointExternalIdentifier,
                           Date effectiveTime,
                           boolean forLineage,
                           boolean forDuplicateProcessing)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
        Remove the metadata element representing a network endpoint. This will delete the endpoint and all anchored elements such as schema and comments.
        Specified by:
        removeEndpoint in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        endpointGUID - unique identifier of the metadata element to remove
        endpointExternalIdentifier - unique identifier of the endpoint in the external asset manager
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • findEndpoints

        public List<EndpointElement> findEndpoints​(String userId,
                                           String assetManagerGUID,
                                           String assetManagerName,
                                           String searchString,
                                           int startFrom,
                                           int pageSize,
                                           Date effectiveTime,
                                           boolean forLineage,
                                           boolean forDuplicateProcessing)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException
        Retrieve the list of network endpoint metadata elements that contain the search string. The search string is treated as a regular expression.
        Specified by:
        findEndpoints in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        searchString - string to find in the properties
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getEndpointsByName

        public List<EndpointElement> getEndpointsByName​(String userId,
                                                String assetManagerGUID,
                                                String assetManagerName,
                                                String name,
                                                int startFrom,
                                                int pageSize,
                                                Date effectiveTime,
                                                boolean forLineage,
                                                boolean forDuplicateProcessing)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                PropertyServerException
        Retrieve the list of network endpoint metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Specified by:
        getEndpointsByName in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        name - name to search for
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getEndpointsForAssetManager

        public List<EndpointElement> getEndpointsForAssetManager​(String userId,
                                                         String assetManagerGUID,
                                                         String assetManagerName,
                                                         int startFrom,
                                                         int pageSize,
                                                         Date effectiveTime,
                                                         boolean forLineage,
                                                         boolean forDuplicateProcessing)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException
        Retrieve the list of endpoints created on behalf of the named asset manager.
        Specified by:
        getEndpointsForAssetManager in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getEndpointByGUID

        public EndpointElement getEndpointByGUID​(String userId,
                                         String assetManagerGUID,
                                         String assetManagerName,
                                         String endpointGUID,
                                         Date effectiveTime,
                                         boolean forLineage,
                                         boolean forDuplicateProcessing)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
        Retrieve the network endpoint metadata element with the supplied unique identifier.
        Specified by:
        getEndpointByGUID in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        endpointGUID - unique identifier of the requested metadata element
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        matching metadata element
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • createConnectorTypeFromTemplate

        public String createConnectorTypeFromTemplate​(String userId,
                                              String assetManagerGUID,
                                              String assetManagerName,
                                              boolean assetManagerIsHome,
                                              String templateGUID,
                                              ExternalIdentifierProperties externalIdentifierProperties,
                                              TemplateProperties templateProperties)
                                       throws InvalidParameterException,
                                              UserNotAuthorizedException,
                                              PropertyServerException
        Create a new metadata element to represent an asset using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new asset.
        Specified by:
        createConnectorTypeFromTemplate in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        assetManagerIsHome - ensure that only the asset manager can update this asset
        externalIdentifierProperties - optional properties used to define an external identifier
        templateGUID - unique identifier of the metadata element to copy
        templateProperties - properties that override the template
        Returns:
        unique identifier of the new metadata element
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • updateConnectorType

        public void updateConnectorType​(String userId,
                                String assetManagerGUID,
                                String assetManagerName,
                                String connectorTypeGUID,
                                String connectorTypeExternalIdentifier,
                                boolean isMergeUpdate,
                                ConnectorTypeProperties connectorTypeProperties,
                                Date effectiveTime,
                                boolean forLineage,
                                boolean forDuplicateProcessing)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
        Update the metadata element representing an asset.
        Specified by:
        updateConnectorType in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectorTypeGUID - unique identifier of the metadata element to update
        connectorTypeExternalIdentifier - unique identifier of the asset in the external asset manager
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        connectorTypeProperties - new properties for this element
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • removeConnectorType

        public void removeConnectorType​(String userId,
                                String assetManagerGUID,
                                String assetManagerName,
                                String connectorTypeGUID,
                                String connectorTypeExternalIdentifier,
                                Date effectiveTime,
                                boolean forLineage,
                                boolean forDuplicateProcessing)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
        Remove the metadata element representing an asset. This will delete the asset and all anchored elements such as schema and comments.
        Specified by:
        removeConnectorType in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        connectorTypeGUID - unique identifier of the metadata element to remove
        connectorTypeExternalIdentifier - unique identifier of the asset in the external asset manager
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • findConnectorTypes

        public List<ConnectorTypeElement> findConnectorTypes​(String userId,
                                                     String assetManagerGUID,
                                                     String assetManagerName,
                                                     String searchString,
                                                     int startFrom,
                                                     int pageSize,
                                                     Date effectiveTime,
                                                     boolean forLineage,
                                                     boolean forDuplicateProcessing)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException
        Retrieve the list of connector type metadata elements that contain the search string. The search string is treated as a regular expression.
        Specified by:
        findConnectorTypes in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        searchString - string to find in the properties
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getConnectorTypesByName

        public List<ConnectorTypeElement> getConnectorTypesByName​(String userId,
                                                          String assetManagerGUID,
                                                          String assetManagerName,
                                                          String name,
                                                          int startFrom,
                                                          int pageSize,
                                                          Date effectiveTime,
                                                          boolean forLineage,
                                                          boolean forDuplicateProcessing)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          PropertyServerException
        Retrieve the list of connector type metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Specified by:
        getConnectorTypesByName in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        name - name to search for
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getConnectorTypesForAssetManager

        public List<ConnectorTypeElement> getConnectorTypesForAssetManager​(String userId,
                                                                   String assetManagerGUID,
                                                                   String assetManagerName,
                                                                   int startFrom,
                                                                   int pageSize,
                                                                   Date effectiveTime,
                                                                   boolean forLineage,
                                                                   boolean forDuplicateProcessing)
                                                            throws InvalidParameterException,
                                                                   UserNotAuthorizedException,
                                                                   PropertyServerException
        Retrieve the list of assets created on behalf of the named asset manager.
        Specified by:
        getConnectorTypesForAssetManager in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        startFrom - paging start point
        pageSize - maximum results that can be returned
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        list of matching metadata elements
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)

      • getConnectorTypeByGUID

        public ConnectorTypeElement getConnectorTypeByGUID​(String userId,
                                                   String assetManagerGUID,
                                                   String assetManagerName,
                                                   String openMetadataGUID,
                                                   Date effectiveTime,
                                                   boolean forLineage,
                                                   boolean forDuplicateProcessing)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   PropertyServerException
        Retrieve the connector type metadata element with the supplied unique identifier.
        Specified by:
        getConnectorTypeByGUID in interface ConnectionExchangeInterface
        Parameters:
        userId - calling user
        assetManagerGUID - unique identifier of software server capability representing the caller
        assetManagerName - unique name of software server capability representing the caller
        openMetadataGUID - unique identifier of the requested metadata element
        effectiveTime - when should the elements be effected for - null is anytime; new Date() is now
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        Returns:
        matching metadata element
        Throws:
        InvalidParameterException - one of the parameters is invalid
        UserNotAuthorizedException - the user is not authorized to issue this request
        PropertyServerException - there is a problem reported in the open metadata server(s)