Package org.odpi.openmetadata.accessservices.datamanager.server.spring

Class ConnectionManagerResource

  • @RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/data-manager/users/{userId}")
public class ConnectionManagerResource
extends Object
    ConnectionResource is the server-side implementation of the Data Manager OMAS's support for topics. It matches the ConnectionManagerClient.

    • Constructor Detail

      • ConnectionManagerResource

        public ConnectionManagerResource()
        Default constructor

    • Method Detail

      • createConnection

        @PostMapping(path="/connections")
public GUIDResponse createConnection​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @RequestBody
                                     ConnectionRequestBody requestBody)
        Create a new metadata element to represent a connection.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - properties to store
        Returns:
        unique identifier of the new metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • createConnectionFromTemplate

        @PostMapping(path="/connections/from-template/{templateGUID}")
public GUIDResponse createConnectionFromTemplate​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String templateGUID,
                                                 @RequestBody
                                                 TemplateRequestBody requestBody)
        Create a new metadata element to represent a connection using an existing metadata element as a template.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        templateGUID - unique identifier of the metadata element to copy
        requestBody - properties that override the template
        Returns:
        unique identifier of the new metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • updateConnection

        @PostMapping(path="/connections/{connectionGUID}")
public VoidResponse updateConnection​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String connectionGUID,
                                     @RequestParam
                                     boolean isMergeUpdate,
                                     @RequestBody
                                     ConnectionRequestBody requestBody)
        Update the metadata element representing a connection.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the metadata element to update
        isMergeUpdate - should the new properties be merged with the existing properties of overlay them?
        requestBody - new properties for this element
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • setupConnectorType

        @PostMapping(path="/connections/{connectionGUID}/connector-types/{connectorTypeGUID}")
public VoidResponse setupConnectorType​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String connectionGUID,
                                       @PathVariable
                                       String connectorTypeGUID,
                                       @RequestBody
                                       MetadataSourceRequestBody requestBody)
        Create a relationship between a connection and a connector type.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the connection in the external data manager
        connectorTypeGUID - unique identifier of the connector type in the external data manager
        requestBody - data manager identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • clearConnectorType

        @PostMapping(path="/connections/{connectionGUID}/connector-types/{connectorTypeGUID}/delete")
public VoidResponse clearConnectorType​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String connectionGUID,
                                       @PathVariable
                                       String connectorTypeGUID,
                                       @RequestBody
                                       MetadataSourceRequestBody requestBody)
        Remove a relationship between a connection and a connector type.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the connection in the external data manager
        connectorTypeGUID - unique identifier of the connector type in the external data manager
        requestBody - data manager identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • setupEndpoint

        @PostMapping(path="/connections/{connectionGUID}/endpoints/{endpointGUID}")
public VoidResponse setupEndpoint​(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String connectionGUID,
                                  @PathVariable
                                  String endpointGUID,
                                  @RequestBody
                                  MetadataSourceRequestBody requestBody)
        Create a relationship between a connection and an endpoint.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the connection in the external data manager
        endpointGUID - unique identifier of the endpoint in the external data manager
        requestBody - data manager identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • clearEndpoint

        @PostMapping(path="/connections/{connectionGUID}/endpoints/{endpointGUID}/delete")
public VoidResponse clearEndpoint​(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String connectionGUID,
                                  @PathVariable
                                  String endpointGUID,
                                  @RequestBody
                                  MetadataSourceRequestBody requestBody)
        Remove a relationship between a connection and an endpoint.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the connection in the external data manager
        endpointGUID - unique identifier of the endpoint in the external data manager
        requestBody - data manager identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • setupEmbeddedConnection

        @PostMapping(path="/connections/{connectionGUID}/embedded-connections/{embeddedConnectionGUID}")
public VoidResponse setupEmbeddedConnection​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String connectionGUID,
                                            @PathVariable
                                            String embeddedConnectionGUID,
                                            @RequestBody
                                            EmbeddedConnectionRequestBody requestBody)
        Create a relationship between a virtual connection and an embedded connection.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the virtual connection in the external data manager
        embeddedConnectionGUID - unique identifier of the embedded connection in the external data manager
        requestBody - data manager identifiers and properties for the embedded connection
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • clearEmbeddedConnection

        @PostMapping(path="/connections/{connectionGUID}/embedded-connections/{embeddedConnectionGUID}/delete")
public VoidResponse clearEmbeddedConnection​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String connectionGUID,
                                            @PathVariable
                                            String embeddedConnectionGUID,
                                            @RequestBody
                                            MetadataSourceRequestBody requestBody)
        Remove a relationship between a virtual connection and an embedded connection.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the virtual connection in the external data manager
        embeddedConnectionGUID - unique identifier of the embedded connection in the external data manager
        requestBody - data manager identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • setupAssetConnection

        @PostMapping(path="assets/{assetGUID}/connections/{connectionGUID}")
public VoidResponse setupAssetConnection​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String assetGUID,
                                         @PathVariable
                                         String connectionGUID,
                                         @RequestBody
                                         AssetConnectionRequestBody requestBody)
        Create a relationship between an asset and its connection.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        assetGUID - unique identifier of the asset
        connectionGUID - unique identifier of the connection
        requestBody - data manager identifiers and asset summary
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • clearAssetConnection

        @PostMapping(path="assets/{assetGUID}/connections/{connectionGUID}/delete")
public VoidResponse clearAssetConnection​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String assetGUID,
                                         @PathVariable
                                         String connectionGUID,
                                         @RequestBody
                                         MetadataSourceRequestBody requestBody)
        Remove a relationship between an asset and its connection.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        assetGUID - unique identifier of the asset
        connectionGUID - unique identifier of the connection
        requestBody - data manager identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • removeConnection

        @PostMapping(path="/connections/{connectionGUID}/delete")
public VoidResponse removeConnection​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String connectionGUID,
                                     @RequestBody
                                     MetadataSourceRequestBody requestBody)
        Remove the metadata element representing a connection.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        connectionGUID - unique identifier of the metadata element to remove
        requestBody - external source identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • findConnections

        @PostMapping(path="/connections/by-search-string")
public ConnectionsResponse findConnections​(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @RequestBody
                                           SearchStringRequestBody requestBody,
                                           @RequestParam
                                           int startFrom,
                                           @RequestParam
                                           int pageSize)
        Retrieve the list of connection metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - string to find in the properties
        startFrom - paging start point
        pageSize - maximum results that can be returned
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getConnectionsByName

        @PostMapping(path="/connections/by-name")
public ConnectionsResponse getConnectionsByName​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @RequestBody
                                                NameRequestBody requestBody,
                                                @RequestParam
                                                int startFrom,
                                                @RequestParam
                                                int pageSize)
        Retrieve the list of connection metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - name to search for
        startFrom - paging start point
        pageSize - maximum results that can be returned
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getConnectionByGUID

        @GetMapping(path="/connections/{guid}")
public ConnectionResponse getConnectionByGUID​(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String guid)
        Retrieve the connection metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        guid - unique identifier of the requested metadata element
        Returns:
        matching metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • createEndpoint

        @PostMapping(path="/endpoints")
public GUIDResponse createEndpoint​(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @RequestBody
                                   EndpointRequestBody requestBody)
        Create a new metadata element to represent a endpoint.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - properties about the endpoint
        Returns:
        unique identifier of the new endpoint or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • createEndpointFromTemplate

        @PostMapping(path="/endpoints/network-address/{networkAddress}/from-template/{templateGUID}")
public GUIDResponse createEndpointFromTemplate​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String networkAddress,
                                               @PathVariable
                                               String templateGUID,
                                               @RequestBody
                                               TemplateRequestBody requestBody)
        Create a new metadata element to represent a endpoint using an existing metadata element as a template.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        networkAddress - location of the endpoint
        templateGUID - unique identifier of the metadata element to copy
        requestBody - properties that override the template
        Returns:
        unique identifier of the new endpoint or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • updateEndpoint

        @PostMapping(path="/endpoints/{endpointGUID}")
public VoidResponse updateEndpoint​(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String endpointGUID,
                                   @RequestParam
                                   boolean isMergeUpdate,
                                   @RequestBody
                                   EndpointRequestBody requestBody)
        Update the metadata element representing a endpoint.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        endpointGUID - unique identifier of the metadata element to update
        isMergeUpdate - are unspecified properties unchanged (true) or removed?
        requestBody - new properties for the metadata element
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • removeEndpoint

        @PostMapping(path="/endpoints/{endpointGUID}/delete")
public VoidResponse removeEndpoint​(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String endpointGUID,
                                   @RequestBody
                                   MetadataSourceRequestBody requestBody)
        Remove the metadata element representing a endpoint.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        endpointGUID - unique identifier of the metadata element to remove
        requestBody - external source identifiers
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • findEndpoints

        @PostMapping(path="/endpoints/by-search-string")
public EndpointsResponse findEndpoints​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @RequestBody
                                       SearchStringRequestBody requestBody,
                                       @RequestParam
                                       int startFrom,
                                       @RequestParam
                                       int pageSize)
        Retrieve the list of endpoint metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - string to find in the properties
        startFrom - paging start point
        pageSize - maximum results that can be returned
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getEndpointsByName

        @PostMapping(path="/endpoints/by-name")
public EndpointsResponse getEndpointsByName​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @RequestBody
                                            NameRequestBody requestBody,
                                            @RequestParam
                                            int startFrom,
                                            @RequestParam
                                            int pageSize)
        Retrieve the list of endpoint metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - name to search for
        startFrom - paging start point
        pageSize - maximum results that can be returned
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getEndpointByGUID

        @GetMapping(path="/endpoints/{guid}")
public EndpointResponse getEndpointByGUID​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String guid)
        Retrieve the endpoint metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        guid - unique identifier of the requested metadata element
        Returns:
        requested metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • findConnectorTypes

        @PostMapping(path="/connector-types/by-search-string")
public ConnectorTypesResponse findConnectorTypes​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @RequestBody
                                                 SearchStringRequestBody requestBody,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize)
        Retrieve the list of connector type metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - string to find in the properties
        startFrom - paging start point
        pageSize - maximum results that can be returned
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getConnectorTypesByName

        @PostMapping(path="/connector-types/by-name")
public ConnectorTypesResponse getConnectorTypesByName​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @RequestBody
                                                      NameRequestBody requestBody,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize)
        Retrieve the list of connector type metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        requestBody - name to search for
        startFrom - paging start point
        pageSize - maximum results that can be returned
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getConnectorTypeByGUID

        @GetMapping(path="/connector-types/{guid}")
public ConnectorTypeResponse getConnectorTypeByGUID​(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String guid)
        Retrieve the connector type metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the service to route the request to.
        userId - calling user
        guid - unique identifier of the requested metadata element
        Returns:
        requested metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)