Page Comparison

Introduction

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

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

Changes to Repository API

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

/**
  * 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. This The new service needs to must extend the IRepositoryService. This is a marker interface which that identifies this the new service as a repository service. Once the service is defined, it needs to must register itself in the repository's implementation. In the future we can have this registration done using spring which will even more configurable, registration will be performed using Spring making configuration easier.

Adding service in detail

To explain this we will use an An example of a repository service that provided management of access control list provides user management features for the repository objects. We created an is shown below. An interface for this service which is described below as follows:

public interface IAclManagerRepositorySecurityManager extends IRepositoryService {

 /** public List<IUser> getUsers() *throws GetKettleException;
the
Permissions of apublic repository object.
   *void setUsers(List<IUser> users) throws KettleException;

  public *ObjectId @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 forceParentInheritinggetUserID(String login) throws KettleException;

  public void delUser(ObjectId id_user) throws KettleException;

  public void delUser(String name) throws KettleException;

  public ObjectId[] getUserIDs() throws KettleException;

  public void saveUserInfo(IUser user) throws KettleException;

  public void renameUser(ObjectId id_user, String newname) throws KettleException;

  /**public IUser constructUser()  *throws SetKettleException;
the
Permissions of apublic repository element.
   *void updateUser(IUser user) throws KettleException;

  public *void @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 aclObjectdeleteUsers(List<IUser> users) throws KettleException;

  public IUser loadUserInfo(String username) throws KettleException;

  public boolean isManaged() throws KettleException;

}

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

IAclManagersecurityProvider aclImpl  = new AclManagerImpl();
registerRepositoryService(IAclManagerKettleDatabaseRepositorySecurityProvider(this, repositoryMeta, userinfo);

  	          // We need to add services in the list in the order of dependencies
		  registerRepositoryService(RepositorySecurityManager.class, aclImplsecurityProvider);

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

Associating UISupport to a repository service

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

Creating UISupport

IAclManager service has a UI component and for that we created a UISupport class extending A UISupport class was created for RepositorySecurityManager service that extends the AbstractRepositoryExplorerUISupport class and implemented implements the setup method.

public class ManageUserUISupport extends AbstractRepositoryExplorerUISupport{

  @Override
  protected void setup() {
    SecurityController securityController = new SecurityController();
    overlayscontrollerNames.add(new DefaultXulOverlay(securityController.getName());
    handlers.add(securityController);
    overlays.add(new RepositoryExplorerDefaultXulOverlay("org/pentaho/di/ui/repository/repositoryexplorer/xul/aclsecurity-enabled-layout-overlay.xul", RepositoryExplorer.class)); //$NON-NLS-1$
    PermissionsController permissionsController = new PermissionsController();
    controllerNames.add(permissionsController.getName());
  
 handlers.add(permissionsController);   }

In the setup method we added any all overlays or/and event handlers that this service will haveprovides were added. Finally we need register , the UI Support class must be registered.

Registering UISupport

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

UISupportRegistery.getInstance().registerUISupport(IAclManagerRepositorySecurityManager.class,  AclUISupportManageUserUISupport.class);

Consuming UISupport classes

The UISupport classes gives us 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 user managements feature then the UI will never expose these features. At present these Currently,  the UI Support objects are being consumed by the repository explorerRepository Explorer.

Finally we need to extend these , you must extend the UISupport object to be applicable to the whole spoon Spoon UI. This will give us a gives you  complete flexibility in add for adding or removing the UI portions from spoonSpoon.