IBM Connections application development state of the union – part 6

Part 5 was about extensions/apps on-premises and this – probably final post – will be about extensions for IBM Connections Cloud. There are different ways to extend IBM Connections Cloud – one is to add links to the app menu and another is to add actual UI extensions to the applications within IBM Connections. This post is about the latter (although the observations about the administration UI applies to both). To get it out of the way from the beginning I might as well say it flat out. IBM has really missed the mark here. The extensibility mechanism for IBM Connections in Cloud is close to unusable from my point of view. Let me explain…

Basically the extension mechanism for cloud is an iframe and you may only extend Communities which is so wrong to begin with. As mentioned previously IBM Connections is a piece of social software that focus on people and not being able to extend Profiles is baffling to me. Using a clumsy UI in the administration portal you can upload a JSON file describing the extension which in turn will make the extension show up in the main UI. The smallest file I could make work is 34 lines of JSON but basically I could do away with 3 lines. Almost all of the JSON I upload is simply cruft that seems to carry over from the on-premises widget container and as I really cannot change it why should I specify it? In essence I can only change the following 3 parameters:

  • defId – seems to be an ID of the widget
  • url – the URL to set into the iframe
  • height – the height of the iframe

Part of the JSON I upload is the widget ID. I have to specify the ID of the widget (defId) but there is no check whether it’s used. Using an already used ID is allowed but only one of the widgets with the same ID shows up which is an issue as this is an obvious copy/paste error on the users part. Also the widget is added to the community page using the defId as the title but shown in the administration UI using a “name” parameter from JSON which is pretty confusing. Part of the JSON I upload is also the actual iWidget that creates and builds the iframe. I can specify my own iWidget description and the only thing that makes it not work is the ajaxProxy rejecting it making the UI fail when users load the community page. There is no upload time check. Often times an invalid JSON file only makes the UI do nothing – there is no response as to what might be wrong.


Once the JSON is uploaded I get an iframe of a static height with a URL set into it. The height is one thing that makes this extension mechanism hard to work with for production apps. Often times the height of the content cannot be decided at deployment time but is only known at runtime and unfortunately there is no way to change the iframe height at runtime. At least nothing which is obvious and/or documented. But now we have an iframe set the URL specified in the application JSON. The iframe is sandboxed with the following policy: “allow-same-origin allow-scripts allow-popups allow-forms”. This restricts the extension and basically it may only do the following:

  • Run JavaScript
  • Make xhr requests to the server it was loaded from (same origin)
  • Open a new window/tab in the browser

There is no way for the widget to even talk to IBM Connections itself – not even the IBM Connections API. The widget may basically show static / server side generated HTML and run JavaScript. The JavaScript may make xhr requests to the server it was loaded from. That’s it.

When the widget loads it may ask the surrounding page for a widget context by registering a message listener and posting a message to the parent page (parent.postMessage). The context looks like this:

   "source": {
      "resourceId": "ff7dd8b4-95d6-4fb4-f094-edb52e5d8eee",
      "resourceName": "Some Community Title",
      "resourceType": "community",
      "orgId": "12345678"
   "user": {
      "userId": "87654321",
      "orgId": "12345678",
      "displayName": "John Doe",
      "email": ""
   "extraContent": {
      "canContribute": "true",
      "canPersonalize": "true"

From the context the widget can figure out who the user is and what community the user is in. The problem is however that the user information is unusable as there is no way my application server can trust this user information. As the context is not verifiable in any way there is no way for my server to trust the information it receives from the extension. The only way to convey user identity to my server is by using SAML and assume that a SAML assertion dance is performed when the iframe contents is loaded so the user has a session cookie relationship with my server. But this is doable – I now know the user identity based on the SAML dance.

Next thing is to make sure the user is actually a member of the community he/she is sending to my server – but oh – there is no way to decide this. My server side code cannot make requests on behalf of the user back to IBM Connections without the user having already performed an OAuth dance and authorized my application to IBM Connections. I could tell the user that we might not have tokens for him/her but it yields a crappy user experience. Plus any authorization granted expires from time to time (at least every 90 days). Also there is no organization wide OAuth authorization capabilities in IBM Connections Cloud like is the case for Google or Microsoft plus there is no super-user for IBM Connections so we’re pretty stuck here.

Now this is pretty bad and combining these things basically makes it impossible to create any kind of customer or ISV solution with a decent user experience. At least if the context is important and the contents is not static.

So what do we do about it? Well IMHO the solution is pretty easy and simple which makes it even worse that IBM decided to ship this capability. Let me suggest the following points:

  • Administration UI
    Fix the administration UI including the widget JSON I have to upload. Only ask for the stuff that actually matter and induce the rest if not specified. If the uploaded file doesn’t validate tell me – maybe even provide a clue as to what’s missing…
  • Make the context verifiable
    When I register a widget add an option to indicate that my server needs to verify the information in the context (the JSON blob above). If I check the box generate a set of asymmetric keys and provide me one of the keys. Now the JSON context could be signed with the IBM Connections part of the key making my server capable of verifying that the information indeed came from IBM Connections. And since it’s asymmetric there is no way for my server to impersonate IBM Connections. Oh and this would make the information in the context trustable even if the customer is not using SAML.
  • Making calls back to IBM Connections possible
    When I register a widget add an option for me to indicate that my server needs to make calls back to IBM Connections on behalf of the user. For additional credits allow me to specify which parts of the IBM Connections API my server may use. In combination with the asymmetric key pair above this option would include an encrypted opaque token in the JSON context blob. This token could be used by my server to authenticate my server and the request back to IBM Connections. It could be a set of automatically generated OAuth tokens but doesn’t need to be. This is a secure solution as we already have a key pair in place so the token could be encrypted using the IBM Connections part of the key pair so that the widget code in the browser cannot use it. Only the server with the matching key may decrypt the token and use it for the IBM Connections API.

Now I’m no security expert but this should be secure and pretty easy to implement. With a single sweep it would make widgets in IBM Connections Cloud way more powerful than widgets on-premises and would make them much easier to develop. Only thing left then is making it possible to adjust the height at runtime but I’ll let that slip for now as a basic oversight in the design of the extensibility mechanism and assume this capability will be available soon anyway.

</rant >

I have a small IBM Connections Cloud community apo on Github if you would like to see a minimal example: IBM Connections Cloud Community App Example

2 thoughts on “IBM Connections application development state of the union – part 6”

  1. Hi Mikkel,

    First of all, let me say that I feel with you when I read about your struggles working with Connections Cloud Extenstions. There’s no doubt that the Extensions administration UI is far from complete. The small amount of documentation that is available is at best incomplete, and unfortunately quite often misleading or incorrect. I really hope IBM will do something about this, if they are serious about Connections Cloud. I also look forward to more options for where to put my Extensions. For example the Profile pages and the Home page.

    However, what caught my attention in your article is your struggle with bringing any sensible content to the iframe widget, as your (local) application server doesn’t know who you are. I’ve been through the same issues, and found my way around this using OAuth. I see that you mention OAuth as well, but that you don’t find this to be a good solution. However, I don’t think I understand all of your concerns. Here’s how I’ve solved it:

    1. I have an XPage that I load in the iframe widget.

    2. The XPage uses a managed bean for authentication with Connections Cloud (CC), and also for retrieving content from CC.

    3. The java class for the managed bean uses the SBTSDK in general and the SmartCloudOAuth2Endpoint specificly for OAuth2 (but I think you also could build your own OAuth2 handler).

    4. The XPage is (of course) registered as an Extension in CC, and I’ve registered an "internal app" in CC which I use for OAuth2 authentication from the bean.

    5. I use the SmartCloudOAuth2Endpoint for SBTSDK-calls to CC. The user is identified through the endpoint, and CC may deliver files, profiles, communities etc related to this user (you).

    Since the user (necessarily) is authenticated with CC when the iframe loads, there is already an existing user session with CC when the XPage asks the managed bean to connect the SmartCloudOAuth2Endpoint. CC acknowledges this, and will re-use the current user session without asking the user to log in. The user must, however, click the regular "Grant access" button to give the registered "internal app" access to his/her CC information. The user may check the "Always grant" option to avoid this later.

    In my experience, this works fine, without any problems regarding expiring tokens etc. As long as the user has a valid CC session, the iframe may deliver content from CC as well.

    When it comes to identifying which community the iframe widget is loaded in, I pick up this info client side from the event listener (as you describe). The community name is then passed on to a method in an RPC controller on my XPage. The RPC method further sets scoped variables on the server, and re-loads some specific XPage elements (partial refresh) that will make use of the Community name.

    I don’t know if this puts any new light to the Extensions capabilities for your part. Just thought I should share my experiences, in case anyone may learn something from my struggles and achievements. Cheers!


  2.  I agree that your approach will work but I still think the user experience is bad. I will wager that normal users do not understand OAuth and why should they have to login again for an application an administrator installed for them. By CC provided tokens for your application you could provide a much better user experience. And a much safer one. By the user granting you access to OAuth you get much more access and for a longer period of time than is actually necessary. 


Comments are closed.