Hitachi Vantara Pentaho Community Wiki
Child pages
  • Registering Services to the Repository in Kettle
Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 10 Next »

Introduction

One of the changes in Pentaho Data Integration 4.0 is the introduction of services for repositories. To support this new concept, the repository API associated with Pentaho Data Integration has changed.

This document describes how you can create these repository services and register them to the repository. In addition, this document also explains how you can dynamically change the UI based on the repository to which the user is connected.

Changes to Repository API

To enable the registering of these repository services, some new methods have been added to the repository API. Details related to these method are described below:

Repository.java
/**
  * Retrieves the current list of of IRepository Services.
  *
  * @return List of repository services
  * @throws KettleException in case something goes horribly wrong.
  */
  public List<Class<? extends IRepositoryService>> getServiceInterfaces() throws KettleException;

  /**
  * Retrieves a given repository service
  * @param  service class name
  * @return repository service
  *
  * @throws KettleException in case something goes horribly wrong.
  */
  public IRepositoryService getService(Class<? extends IRepositoryService> clazz) throws KettleException;

  /**
   * Checks whether a given repository service is available or not
   *
   * @param repository service class that needs to be checked for support
   * @throws KettleException in case something goes horribly wrong.
   */
  public boolean hasService(Class<? extends IRepositoryService> clazz) throws KettleException;

Registering services to repository

To add a new service to repository, create an interface for the service and provide an implementation. The new service must extend the IRepositoryService. This is a marker interface that identifies the new service as a repository service. Once the service is defined, it must register itself in the repository's implementation. In the future, registration will be performed using Spring making configuration easier.

Adding service in detail

An example of a repository service that provides management of access control list for the repository objects is shown below. An interface for this service is described as follows:

IAclManager.java
public interface IAclManager extends IRepositoryService{
  /**
   * Get the Permissions of a repository object.
   *
   * @param Object Id of the repository object
   * @param forceParentInheriting retrieve the effective ACLs as if 'inherit from parent' were true
   *
   * @return The permissions.
   * @throws KettleException in case something goes horribly wrong
   */
  public ObjectAcl getAcl(ObjectId id, boolean forceParentInheriting) throws KettleException;

  /**
   * Set the Permissions of a repository element.
   *
   * @param Acl object that needs to be set.
   * @param Object Id of a file for which the acl are being set.
   *
   * @throws KettleException in case something goes horribly wrong
   */
  public  void setAcl(ObjectId id, ObjectAcl aclObject) throws KettleException;

}


In a repository's implementation the service implementation was instantiated and and the service was registered with repository.

RepositoryImpl.java
IAclManager aclImpl  = new AclManagerImpl();
registerRepositoryService(IAclManager.class, aclImpl);

RegisiterRepositoryService is a convenience method. All it does is adding the service interface and its implementation in a map. Once the services are registered you can the retrieve the service by calling the getService method in the Repository API

Associating UISupport to a repository service

If the new service has a UI component associated with it, you will be required to create a UISupport class and register it in the UISupportRegistry class.

Creating UISupport

The IAclManager service has a UI component and for that a UISupport class was created that extends the AbstractRepositoryExplorerUISupport class and implements the setup method.

UISupportClass.java
@Override
  protected void setup() {
    overlays.add(new DefaultXulOverlay(
    "org/pentaho/di/ui/repository/repositoryexplorer/xul/acl-enabled-layout-overlay.xul")); //$NON-NLS-1$
    PermissionsController permissionsController = new PermissionsController();
    controllerNames.add(permissionsController.getName());
    handlers.add(permissionsController);
  }

In the setup method all overlays or/and event handlers that this service provides were added. Finally, the UI Support class must be registered.

Registering UISupport

The UISupport class must register with its corresponding service interface to get consumed correctly.

RegisterUISupport.java
UISupportRegistery.getInstance().registerUISupport(IAclManager.class,  AclUISupport.class);

Consuming UISupport classes

The UISupport classes give you an opportunity to enable, disable, add, or remove section(s) of UI based on the services offered by a given repository. For example, if a repository does not support access control on its objects then the UI will never expose these features. Currently,  the UI Support objects are being consumed by the Repository Explorer.

Finally, you must extend the UISupport object to be applicable to the whole Spoon UI. This gives you  complete flexibility for adding or removing the UI portions from Spoon.

  • No labels