Whitehorses

The Struggles of Personalization in ADF

Mike Heeren — Tue, 10 Jul 2018 12:39:30 +0000

A Mike Heeren & Richard Olrichs co-production

ADF comes with the out-of-the-box features of personalization. This means that whenever you configure personalisation, users can persist changes they make to the application across sessions and personalize their experience with the application. We have seen that this feature can also confuse some of our users, so it is not always wise to use this. It depends on the use case you have. However, when recently implementing personalization on an ADF 12.2.1.2 application, we had a couple of issues regarding persisting these personalizations to the MDS.

We felt that most of the blogs we came across while implementing these features, share the joyful out-of-the-box configuration. Just select some of the checkboxes in the properties and you are done, ready to enjoy your beer and have your designers and product owners cheer for you.
Sometimes however, real life applications at customers do not match the out-of-the-box configuration and things can become a little bit more tricky than you might expect.

Let’s start at the top, and go through some of the steps you will always need within your application for personalization to work. You need to have authentication and authorization set up. If you also want to follow our struggles, we have posted a sample application at the end of this blog to show both the problems as well as the solutions.

Getting started with customizations

The basic configuration of customization in ADF is pretty simple. We start with a simple ADF application (with authentication already configured), and select the Project Properties > ADF View. Here we check Enable user customization and Across sessions using MDS, as seen below:

When enabling user customizations, the following files are edited:

In the adf-config.xml file the following lines are added:


	
		oracle.adf.view.rich.change.MDSDocumentChangeManager

In the web.xml file the javax.faces.FACELETS_RESOURCE_RESOLVER context-param is changed from oracle.adfinternal.view.faces.facelets.rich.AdfFaceletsResourceResolver to oracle.adfinternal.view.faces.facelets.rich.MDSFaceletsResourceResolver, and the following blocks are added:


	adflibResources
	oracle.adf.library.webapp.ResourceServlet

...

	adflibResources
	/adflib/*

...

	ADFLibraryFilter
	oracle.adf.library.webapp.LibraryFilter

...

	ADFLibraryFilter
	/*
	FORWARD
	REQUEST

...

	oracle.adf.jsp.provider.0
	oracle.mds.jsp.MDSJSPProviderHelper


	org.apache.myfaces.trinidad.CHANGE_PERSISTENCE
	oracle.adf.view.rich.change.FilteredPersistenceChangeManager

Finally, the following block will be added to the project .jpr file:

After this we need to configure the adf-config.xml file and add the oracle.adf.share.config.UserCC Customization Class on the MDS tab. This is a default customization class that is shipped with ADF. You can also write your own, but that is more of a use case for customization than it is for personalization. In our case we’ll just configure the application using the UserCC:

Now you need to configure the components that you want the end user to be able to personalize. This can be done in the View tab. Select the ADF Faces Components Tag Library, because we want to personalize the table and column components, these are default component from ADF Faces. By default all attributes will be persisted, you can uncheck them if you do not wish to persist these:

After the above steps are configured, you can give a fancy demo on your demo application, and everybody is happy. However, in our production application, there were still a few issues to tackle, we struggled with some of these.

Struggle 1: Task flows from libraries combined with a file based MDS on a Windows machine.

Our application was not a simple MVC application, but like many application out there, we used ADF libraries to include taskflows from library projects and included them in a bigger main application. When we turned on personalisation on components from task flows which come from libraries instead of directly from the application, they were not correctly persisted to the file based MDS on Windows machines.

When running the application via JDeveloper (in our example application by right clicking default.jsf in the ViewController project, and selecting Run), we see that the task flow that comes directly from the ViewController project (the table on the left of the screen), behaves as expected. However, when personalizing the table from the task flow that comes from the imported library (so from the ViewControllerLibrary project), we see the following warning in the log files.

We can verify that the preferences were persisted to the MDS for the left table, but not for the right table, by opening the application (with the same user) in another browser:

Unfortunately, this issue occurs when using task flows from libraries in combination with using a file based MDS on a Windows machine. Weblogic is not able to create a file path, which contains !/ (which is used to indicate that the resource is part of a library).

Luckily, in our case all other DTAP environments don’t use a file based MDS, but a database MDS. In the database MDS, we don’t have the file path issues, so there we won’t see this issue. So on all environments except the (local) Integrated WLS, we don’t see these warning logs, and we will see both table personalizations being persisted. It might take you some time to realise this, if you do not want to deploy to Dev or Test without having the Personalization working on your local machine.

Struggle 2: Deploying the application as EAR instead of via JDeveloper

Deploying both from JDeveloper as well as creating an EAR file seems to work. However, there was still some struggle there as well. The personalisation was working when deploying via JDeveloper, but when we would build in EAR from the application via JDeveloper, and deploy it manually to the Integrated WLS via the console, none of the settings were persisted to the MDS, and we saw the following warning in the log files:

By opening the application in different browsers again, we can also confirm that neither of customizations the tables is persisted in the MDS now:

When Personalization across sessions with the MDS is configured, JDeveloper always creates a metadata store usages in the adf-config file at deployment time. This configuration is named MAR_TargetRepos.

It does not matter that we have configured a different metadata store usages within the adf-config. If the MAR_TargetRepos is not present while creating the EAR file, it will be added to the adf-config file. The only solution that we found to this, is by naming our metadata store usages to match the expected default, then it will not override or add anything.

We added the following snippet to the adf-config/adf-mds-config/mds-config tag in adf-config.xml:

Note that we did not set deploy-target to true, because if we do this, our custom MAR_TargetRepos will be overridden with the default implementation again, when building the EAR file. This default implementation does not contain the FileMetadataStore implementation:

Because we want to override the default MAR_TargetRepos, so the personalization will also work when deploying the EAR instead of deploying via JDeveloper, we do not set the deploy-target to true so the default (false) will be used. In this case the FileMetadataStore configuration will be preserved in the EAR file.

If we deploy the new EAR file, we see the same behaviour as we did when deploying it via JDeveloper. Also, when we use the personalization functions on the screen, we will see files being created within the PersDef folder within the %TEMP% environment variable.

This FileMetadataStore configuration is changed (back) to a DBMetaDataStore configuration by an ANT build script, before deploying on the different DTAP environments instead of the Integrated WLS environment. An example of such ANT script can be found below.

Be sure that the WLS_HOME environment variable is set in the system environment variables, and the ear.location property is replaced in the ANT file when you want to use the above example.

Struggle 3: Suddenly our application does persisting during the session.

We have configured the adf-config to persist only certain components and attributes across the session. This works very nice and clear, however, suddenly all the other components also persist their state, just not across the session, but during the session.

It is possible that this is not what you want, it certainly was not what we expected or had in mind for our application, but there is nothing much we can do about it. It would have made more sense to turn this off for all the components and only persist those that were configured to be persisted.

Luckily the ADF components have an attribute persist and dontPersist on them. When reading the documentation on these attributes, it sounds exactly like what we need for our application! Before adding the dontPersist attribute to the hundreds of components we have in the application, we decide to test it on a couple. What we found out was very unpleasing, basically these attributes could be used for documentation purpose or for fun, but it certainly did nothing concerning persistence.

We decided to create our own custom class to adjust the framework and get this working. To achieve this, the context-param org.apache.myfaces.trinidad.CHANGE_PERSISTENCE can be adjusted to a custom class.

At first we tried to extend the oracle.adf.view.rich.change.FilteredPersistenceChangeManager class, which is the class ADF uses by default. However, unfortunately this class is declared final. We decided to create a class that extends the org.apache.myfaces.trinidad.change.SessionChangeManager class, and use the FilteredPersistenceChangeManager as an instance variable. This may not be the prettiest solution, but it serves our purpose:

package nl.whitehorses.personalization.changemanager;

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;

import oracle.adf.view.rich.change.FilteredPersistenceChangeManager;

import org.apache.myfaces.trinidad.change.AttributeComponentChange;
import org.apache.myfaces.trinidad.change.ChangeManager;
import org.apache.myfaces.trinidad.change.ComponentChange;
import org.apache.myfaces.trinidad.change.DocumentChange;
import org.apache.myfaces.trinidad.change.SessionChangeManager;

public class CustomChangeManager extends SessionChangeManager {

	private final FilteredPersistenceChangeManager fpcmInstance = new FilteredPersistenceChangeManager();

	@Override
	public void addComponentChange(final FacesContext context, final UIComponent component, final ComponentChange change) {
		if (component == null || component.getAttributes() == null) {
			return;
		}
		final String[] persistArray = (String[]) component.getAttributes().get("persist");
		if (persistArray == null) {
			return;
		}
		for (final String persistVal : persistArray) {
			if (persistVal != null && change instanceof AttributeComponentChange && ("ALL".equals(persistVal) || ((AttributeComponentChange) change).getAttributeName().equals(persistVal))) {
				fpcmInstance.addComponentChange(context, component, change);
			}
		}
	}

	@Override
	public void addDocumentChange(final FacesContext context, final UIComponent component, final DocumentChange change) {
		fpcmInstance.addDocumentChange(context, component, change);
	}

	@Override
	public boolean supportsDocumentPersistence(final FacesContext context) {
		return fpcmInstance.supportsDocumentPersistence(context);
	}

	@Override
	public ChangeManager.ChangeOutcome addDocumentChangeWithOutcome(final FacesContext context, final UIComponent component, final DocumentChange change) {
		return fpcmInstance.addDocumentChangeWithOutcome(context, component, change);
	}

}

As you can see, the logic for the persist attribute has been implemented in the addComponentChange method. The addComponentChange method from the FilteredPersistenceChangeManager instance, will only be called when the component contains the persist attribute which is set to ALL. Besides the addComponentChange method, all other (public) methods from the FilteredPersistenceChangeManager have been implemented to use the instance variable as well.

Conclusion

After some struggles and adjustments to the implementation and configuration of the application, we got personalization to work in our real world application used by customers. We overcame the struggles, but this was not as easy as the blogs on the internet made us believe beforehand. We hope that sharing this experience, might save you for some of the troubles we had.

To give you some more insight in the code and the struggles, we have created a (simple) demo application AdfPersonalization, to reproduce the issues we had, and which we used to solve them.

This application consists of the default Model and ViewController projects. Also, we added a ViewControllerLibrary project. This ViewControllerLibrary project is imported as a library by the ViewController project.

The AdfPersonalization application can be deployed to Weblogic in multiple ways:

Using the ‘Run’ button in JDeveloper.
Using Application > Deploy > … to IntegratedWebLogicServer in JDeveloper. This can be done to verify that struggle 2 is no longer an issue.
Using Application > Deploy > … to EAR, followed by running the replace-persdef-repo ANT target from the build.xml file. Afterwards the EAR can be deployed to a Weblogic servers, which is capable using a database based MDS. This can be done to verify struggle 1 is no longer an issue.

The source of this project can be downloaded via AdfPersonalization.zip.

Resources

Progressive Web Apps – bridging the gap between apps and websites

Patrick Sinke — Wed, 30 May 2018 07:06:32 +0000

Apps, websites, mobile sites

For a long time, developers had to choose whether they would build a (mobile) web site or an app to reach their audience. Both have their own set of advantages and disadvantages. Web sites are platform independent, but lack functionality and cannot be used offline. Apps deeply integrate with the device on which they are installed but have to be developed for each platform and are not as easily updated.

Progressive Web Apps

The solution for that is called a Progressive Web App. Basically, it’s a website with added functionality. And there are a number of featues that a PWA requires.

First, a PWA-enabled website should contain an SSL certificate in order to prevent Man in the Middle (MitM) attacks between the app and the backend.

Sceond, it contains a JSON file called a Web Application Manifest. This file holds information about the name of the application, links to the web app icons or image objects and details about the splash screen.

Last but not least, a PWA has a feature called service workers. These are little JavaScript programs who enable push notifications, background data loading and caching. But wait, there’s more. They also provide access to important features of your mobile device like location, camera and things like Apple Pay. And another thing, web features like WebAssembly (for executing near-native code in the webbrowser) are possible with service workers too. This property of the PWA truly bridges the gap between web pages and app features.

Are we there yet?

Although the technology is promising, there are still some hurdles to be taken. Not all features of all mobile devices are supported yet. So is Touch ID not useable without an extra layer like Phone Gap or Cordova. Also, push notifications do not work on iOS devices because background processes are required for service workers and not supported (yet).

The word “progressive” in PWA stands for the idea that although not all functionality is supported by every device, the features that are enabled will work anyway, without breaking the entire app. So if push notification do not work, the site is still able to cache and refresh data. Basically, it’s the next step after progressive web sites, that enabled developers to build one site for many different screen resolutions and input types.

If PWA’s are going to be the next big thing is still a question. But they will pave the way for a smoother user experience across devices and a more generic design of apps anyway. The gap between native apps and websites has become narrower, although still not fully bridged.

The MongoDB ObjectId explained in under 2 minutes

Patrick Sinke — Mon, 16 Apr 2018 15:00:40 +0000

As you may have noticed, especially when your background is from a MySQL or Oracle database, is that the unique identifier for database records (or ‘documents’ in MongoDB) is quite different. It’s not a incremental counter, but a long string of characters. 12 bytes in hexadecimal format, to be precise. And although they appear to contain no information, they actually do. This is how an ObjectId is composed.

Let’s take an ObjectId:

507f1f77bcf86cd799439011

The first part is a 4-byte value representing the seconds since the Unix epoch (hence, it’s a timestamp!), the next part is a 3-byte machine identifier unique for every machine, then a 2-byte containing the process id, and finally a 3-byte counter, starting with a random value.

This combination of values (timestamp, machine, process, counter) guarantees a unique value for the ObjectId.

Because the timestamp is included, it’s possible to extract it from the Id. That’s fairly simple, because Mongo provides a function for that:

ObjectId("507c7f79bcf86cd7994f6c0e").getTimestamp()

returns
ISODate("2012-10-15T21:26:17Z")

Just as simple is extracting the stringvalue:

ObjectId.valueOf(("507c7f79bcf86cd7994f6c0e")
 returns 507c7f79bcf86cd7994f6c0e See the MongoDB reference for more examples.

Node.js tutorial part 2; building a proper website

Patrick Sinke — Mon, 12 Feb 2018 14:54:46 +0000

Your first fully functional Node.js application

In the first part of this tutorial we set up a development environment. As you have noticed there, the core of a Node.js application is a server side Javascript file. You will be editing this file a lot and along the while it will grow accordingly.

I think the first step you will take, is change your code so that node.js serves a proper website. This can be an entirely new site, but without much effort an existing one too.

First things first. npm is the tool we used for creating a first application. When installing packages with npm, you have different options for installing them. With npm -g you install global (system-wide) packages, without the -g packages are installed into the current directory/project.

When we’ re on it , install MongoDB on your system. We’re going to use it in our application as a database. Installation is pretty straightforward on most systems, this site is an excellent starting point.

There are a number of npm packages that are of huge value when creating node.js applications, but the choice is enormous. The following list (in no particular order) of packages is especially invaluable:

path
express
mongoose
body-parser

Let’s see how we use this in a simple but functional Node.js application. Create a new directory for your project and run

npm init

The wizard is pretty self-explanatory. Now we install the necessary npm packages. Install them using these commands:

npm install express --save
npm install express-session --save
npm install body-parser --save
npm install mongoose --save

To make things easy for you, here’s a code snippet you can paste into the index.js at the root of your project:

// initiate express middleware
const express = require('express');
const app = express();

// assign the directory 'public' for storing static 
// files (e.g. HTML and CSS)
app.use(express.static('public'));

// enable the parsing of request bodies and 
// simplified handling of JSON content
const bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({extended: true}));

// initiatie Mongoose for MongoDB connectivity
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/rodeo', {
   keepAlive: true,
   reconnectTries: 10
});

// define a schema for a mongoDB collection
const Schema = mongoose.Schema;

var transactieSchema = new Schema({
   userName: {type: String},
   transactieDatum: {type: Date},
   code: {type: String},
   aantal: {type: Number},
   bedrag: {type: Number}
   //  _id: false
},
   {collection: 'transacties'});
mongoose.model('transacties', transactieSchema);

// Do some neat forwarding of the root of your site 
// to a default file
app.get('/', (req, res) => res.sendfile('index.html'));

// a function for handling a post request
postTransacties = function (req, res, next) {
   console.log(req.body);
   var transacties = mongoose.model('transacties');
   var transactie = new transacties(req.body);
   transactie.save(function (err) {
      if (err) {
         console.log(err);

      }
      return res.json({value: 'hello'});
   });

};

// a function for handling a get request
getTransacties = function (req, res, next) {
   var transacties = mongoose.model('transacties');
   transacties.find({}, function (err, data) {
      return res.json(data);
   });

};

// routing for post and get on the /transacties url
app.route('/transacties')
   .post(postTransacties)
   .get(getTransacties);

// finally, let's fire up a webserver at port 3500
app.listen(3500, function () {
   console.log('listening on *:3500');
   module.exports = app;
});

This is not the best practice in terms of maintainability (it’s better to keep your database, router and controller-middleware in different files), but it will demonstrate everything you need for a full-fledged Node.js application including posting and retrieving data.

Final thing you need is a new directory “public”. Create an index.hml there with this contents:

Now, go to the root of your project and type

node index.js

And when you point your browser to http://localhost:3500 a simple input form will be presented.

If you want to check if everything works as expected, fill in the form, press Save and go to http://localhost:3500/transacties . A JSON document will be displayed with all the records you saved.

That’s all. Now you have a fully working skeleton from where you can start building your enterprise website in Node.js!

Enforce the HTML5 max attribute of input items with JavaScript

Patrick Sinke — Sat, 10 Feb 2018 21:02:55 +0000

The HTML5 max and min attribute on input items

The max attribute is introduced in HTML5 and specifies the maximum value for an element. Unfortunately, it doesn’t enforce the maximum value entered when typing in numbers as you might expect.

The syntax for the HTML element is as follows:

number|date“>

With a small JavaScript function it’s possible to make sure no value larger than the max value (or smaller than the min value) may be entered. Just put the following code in your $(document).ready(function) {}:

   $(document).on('keyup', '.myInputItem', function () {
      if (parseInt($(this).val()) >= $(this).attr('max'))
      {
         $(this).val($(this).attr('max'));
      }
   });

The function fires on the keyup event. The if statement compares the value of the input item with the max value. When it is higher, it will replace the contents with the max value.

Mediator throwing incomplete BusinessFaultException

Mike Heeren — Tue, 31 Oct 2017 19:40:41 +0000

A while ago I ran into the issue that business fault information was not returned to the calling system by the Mediator component in the SOA composite. Instead, only a message that a business fault occurred was responded to the calling system. The response would look something like the below example:


	
	
		
			
				env:Receiver
			
			
				oracle.fabric.common.BusinessFaultException

In this blogpost I will describe what caused this issue, and how it could be solved.

Fault policies and Mediators

Let’s start with some information about fault policies in combination with Mediator components. When fault policies are introduced to a composite, you need to keep the following things in mind:

When the Mediator is configured sequencial, only the following fault policy actions are supported on the Mediator component: Abort, Rethrow and Java code.
When the Mediator is configured parallel, only the following fault policy actions are supported on the Mediator component: Retry, Rethrow, Human intervention, Abort and Java code.

What was causing the issue?

In our case the SOA composite exposed both synchronous and asynchronous services. The composite was also using fault policies. There were 2 fault policies defined:

A fault policy for asynchronous services. This fault policy would trigger a Human intervention action.
A fault policy for synchronous services. This fault policy would trigger a Rethrow action.

Because most components in the composite were asynchronous, the fault policy on composite level was configured to the asynchronous fault policy. For all synchronous BPEL components, this fault policy was overridden on component level.

The issue was caused by the fact that the synchronous fault policy was only applied to the BPEL components, and not to the Mediator components. So when a (business) fault was raised in the BPEL component, the fault policy would rethrow the fault to the Mediator. However, the Mediator would try to start a Human intervention action (due to the asynchronous fault policy on the composite level), which is not supported for a sequencial configured Mediator.

This could also be seen in the Enterprise Manager. The rule marked in the image below was not displayed at that moment.

Solving the issue

With the above knowledge, it was not very hard to solve the issue. Instead of configuring the fault policy on composite level to the asynchronous fault policy, we configured the composite fault policy to the synchronous fault policy. For every asynchronous BPEL component the fault policy was overridden on component level.

This resulted in faults like the below example being returned to the calling systems again:


	
	
		
			
				env:Receiver
				
					ns0:fault
				
			
			
				
			
			
			
				
					F12345
					TEST

Sources:

How to compare Mongo _id’s in Javascript

Patrick Sinke — Sun, 15 Oct 2017 11:55:12 +0000

When comparing MongoDB generated _id fields in Javascript, you’ll soon or later find out that the following code will not give expected results:

var id1 = mongoose.Types.ObjectId('58a0625246cb87062919eb62');
var id2 = mongoose.Types.ObjectId('58a0625246cb87062919eb62');
if (id1===id2) {
 console.log('elements are equal but we dont get here!' );
}

Although this appears a valid comparison, the console.log will never be printed. ObjectId’s are objects, and although when printed to the console appear as ordinary text, they cannot be simply compared.

A simple solution is using the .equals() function, which is part of the MongoDB driver:

var id1 = mongoose.Types.ObjectId('58a0625246cb87062919eb62');
var id2 = mongoose.Types.ObjectId('58a0625246cb87062919eb62');
if (id1.equals(id2)) {
 console.log('elements are equal' );
}

IoT on #oow17 and in my life

Maurik-Jan Veenman — Tue, 03 Oct 2017 16:23:34 +0000

Last Sunday I attended an interesting session at Oracle OpenWord. It was a session about how Federal Express, an American company who delivers parcels, used the electronics in cars that monitor tyre pressure, a lot of parameters from the engine and the gps of the car to collect huge amounts of data. With this data they could coach drivers to drive more fluently to save fuel and prevent excessive engine and tyre wear. They saved money because they optimized routes and minimized the time of cars running idle. They could also inform the customer exactly when the parcel would arrive, because they could see live how well the trip is going (deviations or accidents and a very lucky drive were all noticed and used to update the estimated time of arrival.

I thought it was an inspiring session, because they used what is already there (the car electronics, a database), and combine it with a small device that sends all this information via the phone data network to the organization. Then they add clever analytics software and they are much more in control, and can use and maintain their equipment much more efficiently. In the past there was a little buffer taken for many things, now that is no longer necessary, because they can see exactly when, for instance, the tyres of the car need to be resurfaced, because one can see the exact mileage.

The next day Mark Hurd was talking about predictions he had made, and proving that they were right. One of them was that much more devices in our lives will be connected with each other to make our life easier. Until now I had the idea that all these things were not going as fast as he had predicted them.

But suddenly I realized that even in my own life a lot of things are being combined with each other to comfort my life: if I start up my Blu-ray player, my TV is automatically started, my ‘toon’ (smart thermostat and domotica controller) measures how much power I use and tells that to the power company, so that I don’t have to fill in a end-of-year measurement manually anymore. If I step into my car, my phone is automatically connected, and the app ‘flitsmeister’ is automatically started because it detects that the phone connects to my car. If I Google a restaurant on my phone, I can let google maps guide me to there, if I hear a good song, I can let Shazam listen to it, and find the song’s title for me. When I booked Oracle OpenWorld with my credit card, the bank called me to check if that was a normal, wanted transaction.

These are all examples of clever use of things that are there like phones and what’s in them, databases, the data network, the data itself and analytic software to help us make our lives better. I love it, and I am proud to be a part of the industry that makes this happen!

OGh Tech Experience 2017 – recap

Michel van Zoest — Mon, 19 Jun 2017 20:09:45 +0000

On June 15th and 16th 2017 the very first OGh Tech Experience was held. This 2-day conference was a new combination of the DBA Days and Fusion Middleware Tech Experience that were held in previous years. To summarize: OGh hit bullseye. It was two days packed with excellent in-depth technical sessions, good customer experiences and great networking opportunities.

The venue was well chosen. De Rijtuigenloods in Amersfoort is a former maintenance building of the Dutch Railways converted into a conference center. So the backdrop and even the location of some sessions were old train carriages.

Tech Experience Entrance

The first bombshell was dropped in the introduction by OGh Chairman Robin Buitenhuis. Starting July 1st, the OGh will be renamed to nlOUG, the Netherlands Oracle User Group. This will provide OGh with a more international allure and hopefully attract more foreign speakers and visitors to their events.

After the introduction it was time for the first Keynote. Maria Colgan (@sqlmaria) the Oracle Database Product Manager delivered a great talk about bridging the gap between developers and dba’s, by letting them work together as DevOps teams. Even though I don’t agree with her definition of DevOps (I agree more with Lucas Jellema, but more about that later in this blog), I do agree with her sentiments.

Maria Colgan on Oracle Database 12c and DevOps

During her talk a lot of new Database 12c features were shown, that were interesting for both the DBA as the Fusion Middleware attendees. A few highlights:

leveraging REST from the database by using SQL Developer as ORDS (Oracle Rest Data Services)
dbms_json and json_dataguide to implement json directly from/in the database
new Materialized View features like Enable On Query Computation
ALTER TABLE INMEMORY for better performance
dbms_redact to redact data for security reasons

After the first keynote and much needed refreshments due to the tropical temperatures, the parallel sessions started. Because the Tech Experience was a combination of two events, there were 9 simultanious tracks about many different subjects. Ranging from DBA and PL/SQL to Integration & Process and Web & Mobile, choosing an interesting track was easy.

My first session was one by Jon Petter Hjulstad, namely ‘Experiences from SOA 12.2 implementations’. Because my current customer is in a transition from 11g to 12c, this one gave me some insight in what to expect and what to avoid.

Tools of the trade

My second session was also in the Integration & Process track. This one was on ‘Case Management in Process Cloud’ delivered by Ralf Mueller. He showed the audiance the path that Oracle is taking in expanding the Process Cloud with Unstructured or Dynamic Processes by introducing stages that can be invoked by rules, similar to the on-premise ACM implementation. He even did a demo, to show the ease with which a new implementation can be built.
Later Ralf gave a glimpse into the future of Process Cloud by talking about Adaptive Processes. That will be supported by AI and Machine Learning, data based rules and a Deep Learning Algorithm. Stuff out of sci-fi!

After this it was time for some good old SQL. Chris Saxon showed the audience some magic that can be achieved by using some neat features that the Oracle Database has hidden. Some examples are:

SQL Translation Framework
Edition Base Redefinition
Index Organized Tables
Invisible Columns

Don’t ask Tom

My next session was by Sandra Flores (@sandyfloresmx), an Integration specialist from Mexico. She explained her vision on SOA, Microservices and Service Orientation. Especially how they connect to each other. My main takeaway from this session was, that Microservices can be a part of a SOA, but they are both a part of a Service Orientation.

The Samurai Way

The last session of the first day that I visited was by Lonneke Dikmans and Ronald van Luttikhuizen. In this session they showed the audience how Architects and Integration Specialist can start debates on the architecture of a integration implementation.

The day was concluded with a very good dinner and some much needed drinks.

A bit rusty

On the second day of the event, things started off with another keynote. This time it was Duncan Mills, who titled his session “How I learned to stop worrying and love the Cloud”. In his keynote, he explained how he started his life as a young programmer and gradually growed into the person he is now, and what lessons he learned along the way.
It was a fun talk and it provided lots of insights for developers and managers alike.
Duncan explained how an organization can take it’s path towards the Cloud. This path consists of four steps in his opinion, but an organization should not go further up that path than they dare to go. If step 1 is enough for them, you don’t have to go further to be able to profit from the Cloud. If you take it too far, adoption might get too forced.

Duncan Mills – Path to the Cloud

Another great lesson was based on Richard Dawkins book “The Selfish Gene“, about how genes that wanted to grow started the evolotion of organisms. Therefore Duncan introduced us to the Selfish Developer. He explained that helping developers in all their whims (like: “give me another environment to test stuff”) will help an organization evolve.

The Selfish Developer

And finally Duncan explained a list of things he learned along the way.

Be pragmatic
Don’t over-design
(Mostly) Don’t take anyone’s word for it
Strive for automation
Work in short iterations
Make mistakes!

I guess you had to be there, to get this reference

Because the venue was an old railway complex, some session were inside railway cars, like my first parallel session of day two.
Luc Gorissen had an inspiring presentation about Faulthandling in ACM and BPM. It all starts with the functional design. You have to think about the happy-flow, but you should never forget what should happen when something technical (like a failing server) or something functional (incorrect zipcode or unknown user) goes wrong.
Not until you combine your Fault Categories, Fault Strategy, Layering Model, Design Guidelines and Implementation Guidelines, you will get a complete Fault Handling Implementation.

Fault Handling

Next up was Xander van Rooijen of Rabobank. He showed an example of an API Management implementation.
Using Apiary for the API design and API Fortress for testing, they were able to create a full API implementation on Oracle’s API Platform CS bêta environment. Now they wait for Oracle to be able to push it to production.

Another client story was by Froukje van der Wulp and Maarten Smeets of spir-it, the IT department of the Dutch Council of the Judiciary. They explained how spir-it has transformed it’s organization from a classic Waterfall to an Agile environment. This enabled them to tackle large performance issues in their complex applications for digitizing the Judiciary.

Always faster

In the last parallel track I visited a session by Robert van Mölken on Blockchain. For me a very new and unknown subject. But his session gave me insight and I learned that Blockchains are an implementation of the techniques used by Bitcoin.

The final word was for Lucas Jellema. In the third and last keynote he wrapped up the conference.
With many salutes to audience, speakers and organizers he gave some valuable lessons. And he wasn’t afraid to disagree with some of the other speakers. As I said in the beginning of this blog, his definition of DevOps is different from the one that Maria Colgan showed. His description of a DevOps team is more practical: “You build it, you run it, you fix and evolve it”.

We salute you!

Lucas’ talk on bridging the gaps that exist on many levels, left the audience inspired to come back again next year.

If you got curious after reading this blog, please visit the nlOUG website to download handouts from the Tech Experience.

Building OSB 12c releases on resource level using Maven

Mike Heeren — Thu, 12 Jan 2017 08:55:21 +0000

A while ago I published a Whitebook (in Dutch) about building OSB 12c releases on resource level using Maven. In the Whitebook, you could read which functionality we were missing in the regular Oracle Service Bus plugin for Maven and how we were able to create this functionality using a custom Maven plugin.

I have added the code of this custom Maven plugin to the following public repository: https://bitbucket.org/whitehorsesbv/servicebusplugin

Used settings

The custom Maven plugin has been developed and tested on multiple environments, so we can confirm that the Maven plugin is working if you are using the following version(s):

Application	Version
Java	1.7.0_79, 1.8.0_101
Maven	3.3.9
Oracle Service Bus	12.1.3, 12.2.1

Installing the custom Maven plugin

First start to install the custom Maven plugin to your local Maven repository. To do this, you can download both the JAR and the POM file from the download page of the repository. After you have downloaded both files, you can execute the following commands to install it to you local Maven repository:

mvn install:install-file -Dfile=servicebus-plugin-1.0.jar -DgroupId=nl.whitehorses.servicebus -DartifactId=servicebus-plugin -Dversion=1.0 -Dpackaging=jar
mvn install:install-file -Dfile=servicebus-plugin-1.0.pom -DgroupId=nl.whitehorses.servicebus -DartifactId=servicebus-plugin -Dversion=1.0 -Dpackaging=pom

Building a Service Bus project on resource level

Now that the custom Maven plugin is available in the Maven repository, we are able to build OSB projects using this plugin instead of the default Oracle plugin. To do so, open the pom.xml file in the OSB project directory. By default, the pom.xml file will look something like the below example:

pom.xml

 
 
	4.0.0 
	 
		com.oracle.servicebus 
		sbar-project-common 
		12.1.3-0-0 
	 
	nl.whitehorses 
	Employee 
	1.0-SNAPSHOT 
	sbar

If we package the project into an archive using the above pom.xml file by executing mvn package via the command line, we will get an archive that can be used to deploy the OSB project on project level to the OSB. The build archive can be found in the .data/maven folder within the project directory.

If we change the value of the pom.xml file to the below example, and we package the project the project using the same command, we will get an archive which can be used to deploy on resource level via the OSB. In the below example the following files will be added to the archive:

All files within the Business directory.
All files within the Pipeline directory, except UpdateEmployee.pipeline.

pom.xml

 
 
	4.0.0 
	nl.whitehorses 
	Employee 
	1.0-SNAPSHOT 
	sbar 
	 
		${project.basedir}/.data/maven 
		${project.basedir} 
		 
			 
				${project.basedir} 
			 
		 
		 
			 
				nl.whitehorses.servicebus 
				servicebus-plugin 
				1.0 
				true 
				 
					 
					C:\Oracle\Middleware1221\Oracle_Home 
					 
					false 
					 
					RESOURCE 
					 
					 
						**/Business/* 
						**/Pipeline/* 
					 
					 
					 
						**/Pipeline/UpdateEmployee.pipeline

Instead of using the includes and excludes tags, we can also add a resources tag to the pom.xml file, which points towards a configuration file. This can be used to specify which files need to be included and excluded. For example, the below files will result in exactly the same archive as we would get using the includes and excludes tags:

pom.xml

 
 
	4.0.0 
	nl.whitehorses 
	Employee 
	1.0-SNAPSHOT 
	sbar 
	 
		${project.basedir}/.data/maven 
		${project.basedir} 
		 
			 
				${project.basedir} 
			 
		 
		 
			 
				nl.whitehorses.servicebus 
				servicebus-plugin 
				1.0 
				true 
				 
					 
					C:\Oracle\Middleware1221\Oracle_Home 
					 
					false 
					 
					RESOURCE 
					 
					C:\JDeveloper\mywork\Whitehorses\Employee\archiveResources.xml

archiveResources.xml

 
 
	 
	 
		**/Business/* 
		**/Pipeline/* 
	 
	 
	 
		**/Pipeline/UpdateEmployee.pipeline

Adding an Assembly project to add multiple projects to single archive

The final step of creating full OSB release archives on resource level, was that we wanted to add multiple projects to a single archive. We achieved this by first building every OSB project separately, and later build an Assembly application which combines all projects into a single archive file. To do this, we use the parent pom.xml file to build all projects (including the assembly project). It is important that the assembly project is build last.

The parent pom.xml file, which will build every project, including the assembly project, will look something like the below example:

pom.xml

 
 
	4.0.0 
	nl.whitehorses 
	Whitehorses 
	1.0-SNAPSHOT 
	pom 
	 
		 
		Clockwise 
		Employee 
		Office 
		 
		Assembly

The pom.xml file of the Assembly project will look like the below example. It is important that if you add new projects, you don’t only add them to the parent pom.xml file, but you also add them as a dependency to the Assembly project.

pom.xml

 
 
	4.0.0 
	nl.whitehorses 
	Assembly 
	1.0-SNAPSHOT 
	 
		 
			nl.whitehorses 
			Clockwise 
			1.0-SNAPSHOT 
			sbar 
		 
		 
			nl.whitehorses 
			Employee 
			1.0-SNAPSHOT 
			sbar 
		 
		 
			nl.whitehorses 
			Office 
			1.0-SNAPSHOT 
			sbar 
		 
	 
	 
		sbconfig_${project.version} 
		 
			 
				maven-jar-plugin 
				2.6 
				 
					 
						default-jar 
						never 
					 
				 
			 
			 
				maven-assembly-plugin 
				2.6 
				 
					false 
					 
						${basedir}/src/main/assembly/assembly.xml 
					 
				 
				 
					 
						nl.whitehorses.servicebus 
						servicebus-plugin 
						1.0 
					 
				 
				 
					 
						make-assembly 
						package 
						 
							single

This pom.xml file also points to an assembly.xml file, which contains some configuration about how the Assembly archive should be build bij the Maven assembly plugin. This assembly.xml file should look like the below example:

assembly.xml

 
	src 
	 
		sbar 
	 
	false 
	 
		 
			/ 
			true

If you navigate to the directory which contains the parent pom.xml file, and you execute mvn install via the command line, the OSB release will be build.

For a working example of the above, please download: Building-OSB-12c-releases-on-resource-level-using-Maven.zip

Deploying the archive via Maven

It is also possible to deploy the generated (Assembly) archive directly to an OSB server via the Maven plugin. To achieve this, we should add the deploy-assembly goal of the custom Maven plugin to the desired Maven phase. We chose the pre-integration-test phase for deploying the archive to the OSB server. The pom.xml file in the Assembly project can be updated like the below example to connect the Maven pre-integration-test phase to the deploy-assembly goal of the Maven plugin:

 
 
	4.0.0 
	nl.whitehorses 
	Assembly 
	1.0-SNAPSHOT 
	 
		 
			nl.whitehorses 
			Clockwise 
			1.0-SNAPSHOT 
			sbar 
		 
		 
			nl.whitehorses 
			Employee 
			1.0-SNAPSHOT 
			sbar 
		 
		 
			nl.whitehorses 
			Office 
			1.0-SNAPSHOT 
			sbar 
		 
	 
	 
		sbconfig_${project.version} 
		 
			 
				maven-jar-plugin 
				2.6 
				 
					 
						default-jar 
						never 
					 
				 
			 
			 
				maven-assembly-plugin 
				2.6 
				 
					false 
					 
						${basedir}/src/main/assembly/assembly.xml 
					 
				 
				 
					 
						nl.whitehorses.servicebus 
						servicebus-plugin 
						1.0 
					 
				 
				 
					 
						make-assembly 
						package 
						 
							single 
						 
					 
				 
			
			
				nl.whitehorses.servicebus 
				servicebus-plugin 
				1.0 
				
					
						deploy-assembly
						pre-integration-test
						
							deploy-assembly

If we navigate to the directory containing the parent pom.xml file again, we will be able to deploy the release to the OSB server by executing the mvn pre-integration-test statement. The following parameters must/can be added to this command:

Parameter	Required?	Default value
-Dserver.url	Yes	–
-Dserver.username	Yes	–
-Dserver.password	Yes	–
-Ddeployment.preserve.credentials	–	true
-Ddeployment.preserve.envValues	–	true
-Ddeployment.preserve.operationalValues	–	true
-Ddeployment.preserve.securityAndPolicyConfig	–	true
-Ddeployment.preserve.accessControlPolicies	–	true
-Ddeployment.customization.file	No	–
-Ddeployment.session.activate	–	true
-Ddeployment.session.discardOnError	–	true

These settings represent the “Advanced Settings” when manually uploading an archive via the servicebus console.

Good luck building your OSB releases on resouce level using Maven!