Build and deployment instructions for services-api (development)

Postgres changes

Enable pgcrypto extension

In order to generate UUID identifiers in postgres an extension module is required.

• Start by installing the "pgcrypto" module (must have version 1.1 or above for the "gen_random_uuid()" method, see Unable to locate Jira server for this macro. It may be due to Application Link configuration. )
  • In many Linux systems (especially Debian/Ubuntu), pgcrypto is provided in the "postgresql-contrib" package.
    
• Connect to the database using user postgres
• Run the following command: "CREATE EXTENSION pgcrypto;"
• The output of the command if successful is blank, so you can always try to run "SELECT gen_random_uuid();" which should return a result.

Database migration to service based api

Database migration occurs on tomcat start (handled by Flyway). Both existing databases & new installation should work (though please report any errors if you find any).

Maven build instructions

The same build instructions apply as in DSpace 5:

mvn clean package

Ant update

Don't forget to ant update/fresh_install before starting up tomcat again.

The "ant update" or "ant fresh_install" process will trigger a database update. If your database content is important to you (or you wish to test the migration process more thoroughly), you may wish to back it up prior to running Ant.  The migration will obviously modify your existing database. While we think it is "safe", it is not considered "production ready" until 6.0 is released.

Starting tomcat

Finally, start up Tomcat as normal

How to migrate DSpace modules to the service api

Tutorial: Basic class porting

For this tutorial I will explain how one would port the HandleServlet found in the JSPUI module. This is a fairly simple class with a couple of services.

Step 1: Find & declare services

The first step when porting is to find all the services and declare them at the top. So scroll through the class & look for [serviceName]Impl.anyMethod missing methods on what are now database entities, below are two examples:

//Static call to a service method that will fail on compilation 
AuthorizeServiceImpl.authorizeAction(context, item, Constants.READ);
//Another static call to a service method
HandleServiceImpl.resolveToObject(context, handle);
//Method not found on item since item.canEdit() is a business method call & not a simple getter/setter
item.canEdit();
//Method not found on collection since collection.canEditBoolean(true) is a business method call & not a simple getter/setter
collection.canEditBoolean(true);

For each of the services you need use a factory call to retrieve them (or if you are working in a spring bean you can autowire them).

When we add the factory calls at the top of the class (at the top declaration isn't mandatory, but best that we stick to a single way of how to handle things, this makes it easier to see which services are already declared) we get the following:

protected AuthorizeService authorizeService = AuthorizeServiceFactory.getInstance().getAuthorizeService();
protected HandleService handleService = HandleServiceFactory.getInstance().getHandleService();
protected CommunityService communityService = ContentServiceFactory.getInstance().getCommunityService();
protected CollectionService collectionService = ContentServiceFactory.getInstance().getCollectionService();
protected ItemService itemService = ContentServiceFactory.getInstance().getItemService();
protected SubscribeService subscribeService = EPersonServiceFactory.getInstance().getSubscribeService();

Step 2: Integrate the services

The next step is to use the factories to resolve a lot of compilation issues, below are some examples:

//Before
AuthorizeServiceImpl.authorizeAction(context, item, Constants.READ);
///After 
authorizeService.authorizeAction(context, item, Constants.READ);
 
//Before
HandleServiceImpl.resolveToObject(context, handle);
//After
handleService.resolveToObject(context, handle);
 
//Before
item.canEdit();
//After (requires the item & a context, because the service is a singleton & doesn't hold a state the database object should always be passed)
itemService.canEdit(context, item);
 
//Before
collection.canEditBoolean(true);
//After (requires the collection & a context, because the service is a singleton & doesn't hold a state the database object should always be passed)
collectionService.canEditBoolean(context, collection, true);
 
//There could even be some other methods that now require an additional argument that didn't need it before:
//Before
xHTMLHeadCrosswalk.disseminateList(item);
//After (requires a context)
xHTMLHeadCrosswalk.disseminateList(context, item);
 

Step 3: Fix the rest

As seen in the example above some of the services require additional arguments, depending on the method this could be a context, database object, .... A complete list of methods that have changed in this manner is available here DSpace Service based api: API Changelist

Another change easily encountered is the fact that in older DSpace versions an array of objects was returned instead of a list. This has been changed to always return lists. So the following changes will also need to be made:

//Before
Community[] parents = c.getCommunities();
request.setAttribute("dspace.community", parents[0])
//After
List<Community> parents = c.getCommunities();
request.setAttribute("dspace.community", parents.get(0))

Things to out for when porting

Below are a few additional things to look out for when porting, these have not yet been mentioned in: DSpace Service based api#ChangestotheDSpaceapi

• DatabaseManager calls are no longer allowed from the UI, if you find a call to the DatabaseManager, see if a similar method already exists, if not create add a new service method which delegates it to the DAO layer. There should be examples enough available.
• All lists returned from database objects are persistent, if you want to remove an item from this list you can't just use list.remove() since it will give you an exception when testing. Use an iterator & remove it from the iterator