Notes / Domino by Jesse Gallagher 

XAgents to Jakarta REST Services  

By Jesse Gallagher | 2/6/23 2:03 AM | Development - Notes / Domino | Added by Oliver Busse

For a good long time now, XAgents have been one of the common ways to do non-HTML output in an XPages environment - JSON, mostly. I think the technique was codified and the term coined by Stephan Wissel back in 2008 and the idea has been the same since. Effectively, an XAgent lets you write a Servlet but with a bit more scaffolding. Though XPages has a path to use Servlets officially, that method is more out-of-the-way than XAgents and doesn't (without further hoop jumping) give you some niceties like sessionAsSigner.

XPages Jakarta EE 2.9.0 and Next Steps  

By Jesse Gallagher | 11/22/22 4:54 PM | Development - Notes / Domino | Added by Oliver Busse

Keeping with my productive week off, today I release version 2.9.0 of the XPages Jakarta EE Support project. Similar to the previous release, this one contains new features primarily related to Jakarta NoSQL, but also has some improvements for JSF and a bunch of bug fixes and compatibility improvements.

More Open-Source Updates for Notes/Domino 12.0.2  

By Jesse Gallagher | 11/21/22 12:39 PM | Development - Notes / Domino | Added by Roberto Boccadoro

The other day, I talked about some changes/workarounds for Notes/Domino 12.0.2. Today, I made a few updates to some of the open-source projects I maintain, including another update to the generate-domino-update-site Maven plugin.

Notes/Domino 12.0.2 Fallout  

By Jesse Gallagher | 11/18/22 5:12 AM | Development - Notes / Domino | Added by Roberto Boccadoro

Notes and Domino 12.0.2 came out today. Generally, there are some neat features in development and on the server, but there are also a couple things you may run into depending on your workflow and installation type.

The Myriad Idioms For Finding Implementations In Java  

By Jesse Gallagher | 10/21/22 7:35 AM | Development - Notes / Domino | Added by Roberto Boccadoro

A few years ago, I wrote a post about Java service location, which covered things like META-INF/services and OSGI extensions. Today, I'd like to discuss a similar concept: code in a top-level API that finds a specific implementation. For reasons that will become clear shortly, I'll call this the "FactoryFinder pattern".

Upcoming Sessions at CollabSphere 2022  

By Jesse Gallagher | 10/11/22 1:09 PM | Development - Notes / Domino | Added by Oliver Busse

It's CollabSphere time again, and I'm delighted to be involved in a few sessions this time. Since I just very recently did an OpenNTF webinar covering the Jakarta EE Support project, these sessions take the form of roundtables I'm helping lead.

Jakarta NoSQL Driver for Keep  

By Jesse Gallagher | 10/10/22 2:24 AM | Development - Notes / Domino | Added by Roberto Boccadoro

In what has surreptitiously turned into something of a series, I followed up my recent tinkering with Jakarta NoSQL, the AppDev Pack, and Keycloak with doing something similar with Keep. Keep, like the AppDev Pack's Proton task, provides a remote API for Domino data. It differs from the ADP in a couple notable ways:

Jakarta NoSQL Driver for the AppDev Pack, Part 2  

By Jesse Gallagher | 9/27/22 10:00 AM | Development - Notes / Domino | Added by Roberto Boccadoro

In my last post, I talked about how I implemented a partial Jakarta NoSQL driver using the AppDev Pack as a back end instead of the Notes.jar classes used by the primary implementation. Though the limitations in the ADP mean that it lacks a number of useful features compared to the primary one, it was still an interesting experiment and has the nice side effect of working with essentially any Java app server and Java version 8 or above. Beyond the Proton API calls, the driver brought up the interesting topic of handling authentication. Proton has three ways of working in this regard: Anonymous, which is what you might expect based on how that works elsewhere in Domino. This is easy but not particularly useful except in specific circumstances. Client certificate authentication, where you create a TLS keychain for a given user and associate it with a Directory user (e.g. CN=My Proton App/O=MyOrg), and then your app performs all operations as that user. This is basically like if you ran a remote app with NRPC using a client Notes ID. Act-as-User, which builds on the above authentication by configuring an OAuth broker service that can hand out OIDC tokens on behalf of named users. This is sort of like server-to-server communication with the "Trusted Servers" config field in the server doc, but different in key ways.

Jakarta NoSQL Driver for the AppDev Pack, Part 1  

By Jesse Gallagher | 9/12/22 3:18 AM | Development - Notes / Domino | Added by Roberto Boccadoro

Though the bulk of the work I've been doing for the XPages Jakarta EE project is to bring JEE technologies to Domino, the NoSQL driver has been designed to lead a double life: it works in an XPages context, but it's written to not have any XPages dependencies. One reason for this is that I want it to be usable if you use, for example, the Open Liberty runtime project to side-car apps on a Domino server but still use Notes.jar for data access. Another reason for its organization, though, is that I intended for the driver to be portable across implementations. The driver itself is split into a main bundle and a ".lsxbe" implementation bundle. My original thought was to make that ready for a JNX or Domino JNA implementation, but it's pretty flexible.

XPages Jakarta EE In Practice Slides and Video  

By Jesse Gallagher | 8/18/22 1:03 PM | Development - Notes / Domino | Added by Oliver Busse

Earlier today, I presented for OpenNTF's webinar series on the topic of the XPages Jakarta EE Support project. I felt like it went pretty well, and the video and slides are up now.

Adding Transactions to the XPages Jakarta EE Support Project  

By Jesse Gallagher | 7/21/22 1:27 AM | Development - Notes / Domino | Added by Roberto Boccadoro

As my work of going down the list of JEE specs is hitting dwindling returns, I decided to give a shot to implementing the Jakarta Transactions spec. This one's a little spicy for a couple of reasons, one of which is that it's really a codified implementation of another spec, the X/Open XA standard, which is an old standard for transaction processing. As is often the case, "old" here also means "fiddly", but fortunately it's not too bad for this need. Another reason is that, unlike with a lot of the specs I've implemented, all of the existing implementations seem a bit too heavyweight for me to adapt. I may look around again later: I could have missed one, and eventually GlassFish's implementation may spin off. In the mean time, I wrote a from-scratch implementation for the XPages JEE project: it doesn't cover everything in the spec, and in particular doesn't support suspend/resume for transactions, but it'll work for normal cases in an NSF.

Adding Concurrency to the XPages Jakarta EE Support Project  

By Jesse Gallagher | 7/11/22 12:54 PM | Development - Notes / Domino | Added by Oliver Busse

For a little while, I've had a task open for me to investigate the Jakarta Concurrency and MP Context Propagation specs, and this weekend I decided to dive into that. While I've shelved the MicroProfile part for now, I was successful in implementing Concurrency, at least for the most part.

Rewriting The OpenNTF Site With Jakarta EE: UI  

By Jesse Gallagher | 6/27/22 4:13 PM | Development - Notes / Domino | Added by Oliver Busse

In what may be the last in this series for a bit, I'll talk about the current approach I'm taking for the UI for the new OpenNTF web site. This post will also tread ground I've covered before, when talking about the Jakarta MVC framework and JSP, but it never hurts to reinforce the pertinent aspects.

Rewriting The OpenNTF Site With Jakarta EE: REST  

By Jesse Gallagher | 6/20/22 1:41 PM | Development - Notes / Domino | Added by Oliver Busse

In deciding how to kick off implementation specifics of my new OpenNTF site project, I had a few options, and none of them perfect. I considered starting with the managed beans via CDI, but most of those are actually either UI support beans or interact primarily with other components. I ended up deciding to talk a bit about the REST services in the app, since those are both an extremely-common task to perform in XPages and one where the JEE project runs laps around what you get by default from Domino.

Rewriting The OpenNTF Site With Jakarta EE, Part 1  

By Jesse Gallagher | 6/20/22 2:03 AM | Development - Notes / Domino | Added by Roberto Boccadoro

The design for the OpenNTF home page has been with us for a little while now and has served us pretty well. It looks good and covers the bases it needs to. However, it's getting a little long in the tooth and, more importantly, doesn't cover some capabilities that we're thinking of adding.

Working Domino Views Into Jakarta NoSQL  

By Jesse Gallagher | 6/13/22 1:43 AM | Development - Notes / Domino | Added by Oliver Busse

A few versions ago, I added Jakarta NoSQL support to the XPages Jakarta EE Support project. For that, I used DQL and QueryResultsProcessor exclusively, since it's a near-exact match for the way JNoSQL normally goes things and QRP brought the setup into the realm of "good enough for the normal case". However, as I've been working on a project that puts this to use, the limitations have started to hold me back.

XPages Jakarta EE 2.5.0 And The Looming Java-Version Wall  

By Jesse Gallagher | 5/26/22 1:32 AM | Development - Notes / Domino | Added by Roberto Boccadoro

Earlier today, I published version 2.5.0 of the XPages Jakarta EE Support project. It's mostly a consolidation and bug-fix release, but there are few interesting features and notes about the implementation. Plus, as teased in the post title up there, there's a looming problem for the project.

Putting Eclipse Transformer To Use In Dependency Wrangling  

By Jesse Gallagher | 5/24/22 3:28 PM | Development - Notes / Domino | Added by Oliver Busse

Setting code aside, the backbone of the XPages Jakarta EE Support project is its dependency pool. In it, I use my fork of the p2-maven-plugin to wrangle all the spec and implementation dependencies. Aside from just collecting them, this file does a ton of work to create and reconfigure their OSGi bundle rules to get everything working on Domino.

Poking Around With JavaSapi  

By Jesse Gallagher | 5/20/22 3:17 AM | Development - Notes / Domino | Added by Oliver Busse

Earlier this morning, Serdar Basegmez and Karsten Lehmann had a chat on Twitter regarding the desire for OAuth on Domino and their recollections of a not-quite-shipped technology from a decade ago going by the name "JSAPI". Seeing this chat go by reminded me of some stuff I saw when I was researching the Domino HTTP Java entrypoint last year. Specifically, these guys, which have been sitting there since at least 9.0.1

Upcoming Sessions With OpenNTF and at Engage  

By Jesse Gallagher | 5/12/22 12:50 PM | Development - Notes / Domino | Added by Oliver Busse

This month contains a few presentations and sessions of note for me, and I realized I should compile a list. While I won't personally be attending Engage this year, it's shaping up to be a good conference and OpenNTF and Jakarta EE will be well represented (in chronological order):

So Why Jakarta?  

By Jesse Gallagher | 4/28/22 4:56 PM | Development - Notes / Domino | Added by Oliver Busse

I've spent a lot of time over the last while tinkering with the XPages Jakarta EE Support project in particular and Jakarta technologies in general, and I figured it'd be worth discussing a bit why I like this stack and why I think it's worth putting work into. There are a couple facets to this, I think. Why is it good on its own? Why is it good as a complement or replacement for XPages? And why is it good compared to the other roads offered for Domino developers?

Structure of the Domino Web App Container  

By Jesse Gallagher | 2/26/22 3:30 AM | Development - Notes / Domino | Added by Martin Pradny

My fiddling with the XPages Jakarta EE project in recent days has gotten me thinking about this HTTP Service layer again, and I think it'll be interesting to expand how this whole layer works (at least as I understand it). Along with this post, it might be useful to peruse the slide deck for AD105 from LotusSphere 2011. There's a lot of good stuff in there, and basically, nothing has changed in the intervening 11 years.

What To Do With All This XSP Markup? Redux  

By Jesse Gallagher | 2/18/22 2:36 AM | Development - Notes / Domino | Added by Roberto Boccadoro

About a year ago, I wrote a post discussing what I saw as potential future options for all the XPages code we've collectively written over the years. That post was written with the assumption that the future life of an XPages app isn't XPages as it exists today - while that's still a possibility, it's a lot less fun to speculate about. As it has been for years, this remains on my mind, but my recent addition of JSF to the XPages Jakarta EE project caused it to bubble back to the top of my musings.

JSF in the XPages Jakarta EE Support Project  

By Jesse Gallagher | 2/11/22 1:33 PM | Development - Notes / Domino | Added by Oliver Busse

When I talked about adding Jakarta NoSQL to the JEE support project, I mentioned how that in a way completed the pitch for this project as a full development mechanism. With data access and MVC+JSP in place, now it provides tools to build REST-based or server-rendered UIs backed cleanly by Domino data. Neat!

Building a Full Domino Image for JUnit Tests  

By Jesse Gallagher | 1/23/22 3:06 PM | Development - Notes / Domino | Added by Oliver Busse

Last year, I wrote about how I built images to use Testcontainers to run tests against a Liberty app that uses a Domino runtime. In that situation, I used the Domino Docker image from Flexnet but then pulled out the program files and stock data, mixed with pre-configured server support files from the repository.

DQL, QueryResultsProcessor, and JNoSQL  

By Jesse Gallagher | 1/14/22 11:23 AM | Development - Notes / Domino | Added by Roberto Boccadoro

As I've been adding new technologies to and talking about the XPages Jakarta EE project, I've kind of danced around a major missing layer: data access.

Intercepting Class Loading in OSGi, A Travelogue  

By Jesse Gallagher | 1/11/22 1:55 AM | Development - Notes / Domino | Added by Roberto Boccadoro

Yesterday, I had a problem. I was trying to get MicroProfile Config working inside an NSF to add to the XPages Jakarta EE project, and I was severely blocked by odd behavior. To describe that, I'll lightly cover what MP Config is. It's a CDI extension that allows you to annotate properties on a bean to indicate that they're intended to come from an available configuration source - often a .properties file in the project, but it's a pluggable system.

Migrating a Large XPages App to Jakarta EE 9  

By Jesse Gallagher | 1/7/22 1:59 AM | Development - Notes / Domino | Added by Oliver Busse

Last month, I moved my XPages Jakarta EE project to JEE 9, which involved the large hurdle of switching package names from javax.* to jakarta.*. That was all well and good for the project and opened the door to further improvements, but it's one thing to do it in a support library and another to move an actual large project over.

Updating The XPages JEE Support Project To Jakarta EE 9, A Travelogue  

By Jesse Gallagher | 12/15/21 10:16 AM | Development - Notes / Domino | Added by Roberto Boccadoro

I think it's been a little while since I talked about the XPages Jakarta EE Support project of mine. The goal of that is sort of the inverse of the XPages Runtime project: rather than bringing XPages to a proper modern app server, the JEE Support project brings a handful of current Jakarta EE specs to XPages. It started out a few years ago as a sort of proof-of-concept, but I've since been using it for client work to do things like use newer Jakarta REST (née JAX-RS), CDI, and newer EL in XPages and OSGi bundles.

Java's Shakier Old APIs  

By Jesse Gallagher | 12/13/21 2:15 AM | Development - Notes / Domino | Added by Roberto Boccadoro

In my last post, I sang the praises of InputStream and OutputStream: two classes from Java 1 that, while not perfect, remain tremendously useful and used everywhere. Then, a tweet by John Curtis got me thinking about the opposite cases: APIs from the early Java days that are still with us, are still used relatively frequently, but which are best avoided or used very sparingly.