Friend timeline (click to show fullsize)

Architecture

The ARSocial application consists of several parts:

• ARDBC Plugin for listing tweets, mentions, direct messages and search

The ARDBC Plugin treats the twitter feeds (friends, direct messages, search) as a database source. Because of the speed of the Twitter API we can do fast searches and show all relevant information, mentions and direct messages. It also allows for the creation of tweets, replies and direct messages.

• ARSocial Console form, for an overview of all twitter related items

This will be the main form for the users of the application. It is meant to keep an overview of all tweets that are sent by friends, mentions of the twitter account and searches (for example tweets that mention your company name)

• Vendor and Regular forms

Vendor Forms are built from the ARDBC Data sources to show the information in the Tables of the console. Regular forms are used to store sent Tweets and Direct Messages.

All items and source code can be found in the download package.

What you will need

• BMC Remedy AR System 7.5 server
• Midter 7.5
• Remedy Developer know-how
• Plugin Server know-how
• Java know-how
• A twitter account
• An AR Server that you can break without getting people angry at you (really, I’m serious)

You can download a ‘developer preview’ of the application here: arsocialpreview

at the moment there’s only standard twitter client functionality implemented, and there is no direct integration into the ITSM Suite, however because of the architecture including Vendor Forms it is quite easy to integrate into any itsm and custom built applications. Over the next few weeks I will expand the plugin and the application.

For now please be aware there are several open issues, including ordering of tweets in the table fields and missing functionality in the stand-alone application.

Please provide feedback on BMCDN communities, contact me on twitter or send an email.

For that we use the SHARE:Application_Properties Form. This form stores all information about installed BMC applications. It is typically installed if you install ITSM 7.x (It is standard installed on ARSystem 7.5)

The entries in this form are not stored and readable in a very user friendly way. Sometimes we just want to information at a glance about which applications are installed, which patch level we’re at and which languages are there. What our Java application does is it will query the form, get the separate entries that belong to the same application together and print it on the screen.

Let’s have a look first at how we get the information from the ARSystem form. First we define which fields we want to get back. For this we create an array of integers of the field id’s:

int[] fieldsFromShareApp = new int[2];

fieldsFromShareApp[0] = 400081800; // Property Value

fieldsFromShareApp[1] = 400081600; // Application ID

Then we create a QualifierInfo object, which is our query that we will run. The easiest way to creat an object like this is to use the following syntax:

QualifierInfo qualSearch = context.parseQualification(“SHARE:Application_Properties” , “‘Property Name’ = “Name”");

We call the parseQualification function and give it two parameters: the Form name and the qualification as we would put it in the form. Here we use the Database names for the fields, we can also use the field labels. In that case we would use the ParseQualification() function with three parameters: Form name, View Name and Qualification.

Once we have the QualifierInfo object we use it to run the search:

List<Entry> foundAppNames = context.getListEntryObjects(“SHARE:Application_Properties” , qualSearch, 0, 0, null, fieldsFromShareApp, false, null);

This will give us a List of Entry objects that match the qualification.  For us these are all entries where the Property Name field holds the value Name. For the other options that we can specify here please consult the ARS Java API Javadoc documentation.

We can see how entries are returned by using the .size() function of the List<Entry> object:

System.out.println(foundAppNames.size() + ” Applications in SHARE:Application_Properties”);

We repeat this step to also retrieve the version, patches and languages installed on the server.

Then we loop through our applications to match up the  names with versions, patches and languages:

for (int i = 0; i < foundAppNames.size(); i++)

            {

            Entry foundApp = foundAppNames.get(i);

      String appName = foundApp.get(400081800).toString();

      String appID = foundApp.get(400081600).toString();

      <……….>

In the above function we browse through the Entry Objects that we have and set the appID String to hold the application InstanceID. We use this ID to compare it to the Application Instance ID in the version information.

      // now find the versions

      for (int v = 0; v < foundAppVersions.size(); v++) {

            Entry foundAppVersion = foundAppVersions.get(v);

            String appIDVersion = foundAppVersion.get(400081600).toString();

                  if (appIDVersion.equals(appID)) {appVersion = foundAppVersion.get(400081800).toString();

                        }

                  }// end for loop versions

At the end we display the information in a readable format for the user:

System.out.print(appName + ” Version: ” + appVersion);

      if (appPatch != null) {

                        System.out.print(” Patch ” + appPatch);

            }

      if (appLanguagepack != null) {

                        System.out.print(” ” + appLanguagepack);

            }

                  System.out.println();

      } // end for loop appNames

You can find the full source code to the application here: arsystemapplicationinfo

I will go through some of the (I think) best new options in AR System 7.5 in a few posts, starting off with some GUI stuff and going on to the CMDB (which has a complete new user interface!).  Unfortunately I have a few projects lined up at the moment at work so posting will be a bit light over the next few weeks.

One of the coolest (and easiest for developers) GUI enhancement is the Auto-completion. Where in Remedy we used to have to create workflow where a user would press enter in a field and search the database this is now automatically done by the Midtier. Here’s an example of how it looks:

Here I just typed an a into the field, the midtier gave me back all the menu items that have an a in the value. This is great news for all the users who want to use the keyboard only and not be bothered with mouseclick on menu items.

The option is simply enabled by attaching a menu to a field and setting the following option in the field properties:

It is under the Display Options in the Developer Studio (which I’ll look at in another post). Unfortunately this option only seems to work in the Midtier at the moment.

What we first of course do is get a proper ARServerUser, as usual we will create one hardcoded for the example.
ARServerUser context = new ARServerUser("Demo", "", "","192.168.184.128")

Now we use the ARServerUser.getListLicense() method to get a List of LicenseInfo objects:

List<LicenseInfo> licenseInfo= context.getListLicense(null);

What we do now is walk through the List<LicenseInfo> that we got (in licenseInfo) and show some information about it.

for (int i = 0; i < licenseInfo.size(); i++) {
LicenseInfo licInfo = licenseInfo.get(i);
System.out.println(licInfo.getlicType() + " " + licInfo.getNumLicenses() );
}

We show the Type of the license (ie. BMC Incident Management Application, User Floating, etc) and the number of licenses.

If you want to see all the information that we can get back about license information have a look at the LicenseInfo object in the Javadoc Documentation.

You can download the complete source for this example here:arsystemlicenseinfo

This entry is part of the BMC Remedy ARSystem Java api series

In this example we will get information back about the server, operating system and databank. We are using the getServerInfo(requestList) method for that.

We first specify which information we want to get back from the server:

int[] requestList = new int[7];
requestList[0] = ServerInfo.DB_TYPE;
requestList[1] = ServerInfo.SERVER_IDENT;
requestList[2] = ServerInfo.OS;

We create a new integer array and fill it with the static values that we want. For example ServerInfo.DB_TYPE is the type of database. If you want to have a complete list of all the information you can get back refer to the ServerInfo class in the javadocs.

Now we go to the server and ask for a ServerInfoMap of the information. We use the .getServerInfo() method from ARServerUser for that.

ServerInfoMap serverInfoMap = context.getServerInfo(requestList);

What we have now is an object that is filled with the information we requested, we can get this information out by using the .get method of our ServerInfoMap object. like this:

System.out.println("Database Type: " + serverInfoMap.get(1));
System.out.println("Database Version: " + serverInfoMap.get(Constants.AR_SERVER_INFO_DB_VERSION));
System.out.println("Full Hostname: "+ serverInfoMap.get(Constants.AR_SERVER_INFO_FULL_HOSTNAME));

As you can see for the key we can use either the ServerInfo.INT, Constants.INT or the normal integer values.

You can download the full source code here: arsystemserverinfo (don’t forget to change the servername)

Also it seems I had an old email address at the about page. I updated it and it should be fine now.

One of the major changes for ARS 7.1 is that it has a new Java API. It looks and feels like it is a complete rewrite from the original API. From the BMC documentation:

The primary goals of this API revision are to simplify the interface and eliminate drawbacks of the 7.0 API. Changes include:

• Simplified interface.
• More Java-friendly.
• Use of Java typed-collections.
• Improved stability, performance, and ease of deployment.
• Increased developer productivity by means of better named API methods, intellisense of IDEs, and documentation.
• Drive towards a “pure” Java implementation and eventually eliminate Java Native Interface (JNI) use.

While this is all true, one of the main drawbacks is that you almost completely have to rewrite old Java applications if you want to use them with the new API.

However if you are writing new Java applications this new API is the best release ever. I only played around with it a short time but was really impressed by how it all fits together. Lots and lots of irritating String wrappers have been dropped, multiple ‘nested’ items have become uncluttered and the toString functions now returns nice Strings instead of garbled nonsense.

Sample Code

For the sample code (and all ARS Java API 7.1 code) to work you will need Java 1.5.0_12 or later. I personally use Eclipse 3.2 Europa (Eclipse IDE for Java Developers) as my development environment, however you can of course use any.

Full source code of samples with comments download (click)

Let’s take a look at creating a new Entry in a Form (yes, they are called Forms now!)

ARServerUser context = new ARServerUser("Demo", "", "", "localhost");
Entry newEntry = new Entry();

try{
System.out.println(context.createEntry("XQSR:JavaExample", newEntry));
}
catch(ARException arException){
arException.printStackTrace();
}
}


Yes, that is indeed all, no need for anything more. The Entry Class now holds a map with the Field IDs (integers) and Value objects. This is a great improvement over the EntryItem[] entryList = new EntryItem[3]; ‘fun’ that was in previous API versions.

As for retrieving an Entry, changing values and submitting it again the following example should give a quick impression:

ARServerUser context = new ARServerUser("Demo", "", "", "localhost");

}
catch(ARException arException){
arException.printStackTrace();
}

We fill an integer array with all Field IDs we want to retrieve, make a call to the DB, print out the values, set another field with a value and save it again. Again, no things like:

entry.setEntryItems(entryItems);
entry.store();

Where we had to set an EntryItems object and fill it with Field IDs and Values separate, we now go to the Entry object, and specify where to save it.

There’s a whole lot more to this API than I said here in this small article, unfortunately I don’t have too much time explore it all at the moment. Once I start writing more applications with it I’m sure other new functions and possibilities show up.

Conclusion

A great step forward for the ARS Java API. Of course it is never fun to break backwards compatibility with version 7.0 and earlier, but at of course those applications will still run with the old libraries against a 7.1 server. If you start writing a new Java application and use the 7.1 API you’ll never want to return the old one.

Full source code with comments download (click)

One of the new options in 7.1 is the option to disable the Status History for forms. This has the advantage that the Status History tables in the database do not need to be updated. Theoretically this could save a lot of time.

Functionality

The Status History of a form can be disabled by going to Form Properties and checking the ‘Disable Status History’ button on the ‘Basic’ tab. This has to be done for each form separate.

Test

 To test out this new functionality I built a small application (Download here to test yourself). It has two forms, one with Status History enabled and one disables. Both forms have 1000 records. Separate is a Display Only field with a button and four fields, each recording the time it takes to set the status of all records to Assigned and back to New. The four times it records:

• Changing status of 1000 records with Status History
  • Using Active Links
  • Using Filters

• Changing status of 1000 records without Status History
  • Using Active Links
  • Using Filters

 The improvements speak pretty much for themself, keeping in mind that the testenvironment is a bit extreme.

Testhardware: VMWare Workstation on Core 2 Due 2.0 Ghz with 2 Gb RAM. VMWare RAM: 1552 Mb

The following times (seconds) are averages over 5 tests:

As expected the biggest percentual gain is on the server, almost 20% !

 SQL

If we look at the SQL that gets generated when updating one record we can see how we get there. this is the SQL that gets generated when updating a ticket in the user tool with Status History enabled:

*/BEGIN TRANSACTION
*/OK
*/UPDATE T1676 SET C7=1,C5=’Demo’,C6=1189331127 WHERE C1 = ‘000000000000001′ AND ((C6 <= 1189331110) OR (C5 = ‘Demo’))
*/OK
*/UPDATE H1676 SET T1=1189331127,U1=’Demo’ WHERE entryId = ‘000000000000001′
*/OK
*/COMMIT TRANSACTION
*/OK
*/SELECT C1,C2,C3,C4,C5,C6,C7,C8,0 FROM T1676 WHERE C1 = ‘000000000000001′
*/OK
*/SELECT entryId,T0,U0,T1,U1,T2,U2,T3,U3,T4,U4 FROM H1676 WHERE entryId = ‘000000000000001′
*/OK

As you can see first we update the ticket table (T1676), then the status history (H1676), after that we retrieve the ticket first, and then again the status history.

The following SQL is without Status History:

*/BEGIN TRANSACTION
*/OK
*/UPDATE T1677 SET C7=1,C5=’Demo’,C6=1189331073 WHERE C1 = ‘000000000000001′ AND ((C6 <= 1189331035) OR (C5 = ‘Demo’))
*/OK
*/COMMIT TRANSACTION
*/OK
*/SELECT C1,C2,C3,C4,C5,C6,C7,C8,0 FROM T1677 WHERE C1 = ‘000000000000001′
*/OK

 As you notice, 50% less SQL statements! This is of course only because there is no further workflow on the form, large forms with lots of checking and other workflow (push fields) will not notice too much performance improvement. However this will drastically improve the performance of mass updates through the Atrium Integration Engine (the application formely known as EIE).

Database

When disabling the Status History functionality, all information in the H table is deleted, however the table itself is not removed from the database.

 Conclusion

Very neat feature, that on mass updates will improve the perfomance a lot. In normal daily use it is unlikely that users will have a notable performance increase when updating tickets, but of course it will ease up on the load of a database. It would perhaps have been nice to have a general checkbox to disable all Status History on a server.