Category Archives: JVM

Heroku add Java support but dumps containers!

Posted by on August 28, 2011 1 comment

Recently I have reviewing various cloud solutions and what impact this has on the way you create/architect applications and I have come to the conclusion they are often way too complicated for most existing applications to be effectively hosted in the cloud in a scalable way.

However I was very surprised to see Heroku have introduced support for Java but I was more surprised to see that they have chosen not to include JEE container support.

Which on first thoughts seems odd but given the complexity of implementing a multi-language solution within their environment a JEE container would be an unnecessary hinderance in the performance/scalability of the application.

So yeah… good choice, I wonder if anyone else will drop the JEE container too in their Java/Cloud solutions?

Scripting Languages and COBOL

Posted by on January 19, 2010 2 comments

The use of scripting languages with other languages has increased over the last couple of years, from a simple case of interoperability, reuse of scripting code to allowing your code to customised via the user of external scripts. All of which are real world examples I have seen customers use.

Interoperability between languages is very important to COBOL environments just as much as other languages. Some platforms such as Microsoft’s .Net with their CLR makes life much easier by allowing all languages to share a common infrastructure ie: the instruction set and the VM (MSIL and CLR) along with a base class library to get you started.

Environments such as Sun’s VM (JVM) provide two different approaches to interoperability with Java, the first is via JNI/JNA and the second is producing bytecode that runs as is on the VM.

Although the Micro Focus COBOL compiler does not support JVM bytecode or Java source generation it does have support for invoking classes/methods via the OO invoke verb.

This mechanism is very simple to use, you just need to let our object COBOL runtime know the class is a Java class, which can be done by placing $JAVA$ before the name of the class and ensuring the class itself can be found by the JVM itself usually by adding an extra directories or .jar files to the CLASSPATH environment variable.

With Java 6.0 and JSR 223 support for Java based scripting languages were provided via the package javax.script.

Java has a wealth of scripting languages from awk to xlst. My favourites being jpython, jruby and javascript.

The java.net website has a comprehensive list of scripting languages -
https://scripting.dev.java.net/.

To use the scripting packages, you first need to create a ScriptEngineManager, then use this to create a specific ScriptEngine object for your chosen scripting language and use it.

For example:

  • Create a ScriptEngineManager object.
  • Retrieve a ScriptEngine object from the manager.
  • Evaluate a script using the ScriptEngine object.

    • In COBOL this is quite simply:

          *> ooctrl(+p) required for COM and Java classes
          *> ooctrl(-f) used to preserve case of method names for Java
          $set ooctrl(+p) ooctrl(-f)

           class-control.
               cls-Script-EngineManager is
                   class "$JAVA$javax.script.ScriptEngineManager"
               cls-Script-Engine is
                   class "$JAVA$javax.script.ScriptEngine"
               cls-object is
                   class "$JAVA$java.lang.Object"
               cls-System is
                   class "$JAVA$java.lang.System"    
               cls-PrintStream is
                   class "$JAVA$java.io.PrintStream"
              .

           working-storage section.
           01 ws-obj-sem     object reference cls-Script-EngineManager.
           01 ws-javascript  object reference cls-Script-Engine.
           01 ws-obj         object reference cls-object.

           01 ws-pout        object reference cls-PrintStream.
           procedure division.
             invoke cls-Script-EngineManager "new"
                 returning ws-obj-sem
             end-invoke

             invoke ws-obj-sem "getEngineByName" using
                 "JavaScript" returning ws-javascript
             end-invoke

             invoke ws-javascript "eval" using
                 z"print('Hello, world!')"
                 returning ws-obj
             end-invoke

             if ws-obj not equal null
              invoke cls-System "getout" returning ws-pout
              invoke ws-pout "println"   using ws-obj
              invoke ws-pout "finalize"  returning ws-pout
              invoke ws-obj "finalize"   returning ws-obj
             end-if

          $if NO-FINALIZE not defined
             invoke ws-obj-sem "finalize"    returning ws-obj-sem
             invoke ws-javascript "finalize" returning ws-javascript
          $end
            stop run.

    The actual Javascript being execute is contained in the invoke statement, which is simply:

    print('Hello, world!')

    To use the above example, we first need to compile the code and run it.. which is done as follows:

    C:\jscripting\HelloWorld>cobol cbljscript.cbl int();
    Micro Focus Net Express V5
    Version 6.0.00059  Copyright (C) 1984-2009 Micro Focus (IP) Limited.
    URN AXCGG/AA0/00000
    * Checking complete with no errors - starting code generation
    * Generating cbljscript
    * Data:         848     Code:        1992     Literals:         904

    C:\jscripting\HelloWorld>runm cbljscript
    Micro Focus Net Express V6.0.00059                          
    RUN TIME ENVIRONMENT Copyright (C) 1984-2009 Micro Focus (IP) Limited.        
    URN AXCGG/AA0/00000                                                            
    Hello, world!

    This is just the start, the next thing piece that is required with interoperability to another language is the ability to pass parameters to in and out of the script. Luckily for us the clever chaps on the jsr group have provided ‘put’ and ‘get’ methods that allows us to simply put a name parameter and get the resulting updated or new parameter.

    So consider the example, where we need to setup a parameter called ‘message’ for the script and then read a parameter called ‘replyMessage’ after the script has been executed. The javascript to do this is:

    /* Do some insanity checking! */
    if (typeof(message) == 'undefined')
    {
        message = "ERROR - 'message' has not been setup"
    }

    println(message)

    replyMessage = "Hello from javascript"

    To setup the message parameter, we just need todo.

           *> Put a variable in engine, so the javascript
           *> can use it.
              invoke ws-javascript "put" using
                 z"message"
                 z"Hello World from COBOL!"
              end-invoke

    The after the script has executed, we just need to use the ‘get’ method..

           *> get a variable in engine
              invoke ws-javascript "get" using
                 z"replyMessage"
                 returning ws-message
              end-invoke
     
           *> now display the replyMessage if it is available
              if ws-message not equal null
                invoke ws-pout "println"   using ws-message
              else
                display "Javascript did not set a replyMessage var"

    The completed COBOL example below, uses a side file for the javascript too, the code is as follows:

          *> ooctrl(+p) required for COM and Java classes
          *> ooctrl(-f) used to preserve case of method names for Java
          $set ooctrl(+p) ooctrl(-f)

           class-control.
               cls-Script-EngineManager is
                   class "$JAVA$javax.script.ScriptEngineManager"
               cls-Script-Engine is
                   class "$JAVA$javax.script.ScriptEngine"
               cls-object is
                   class "$JAVA$java.lang.Object"
               cls-System is
                   class "$JAVA$java.lang.System"    
               cls-PrintStream is
                   class "$JAVA$java.io.PrintStream"
               cls-FileReader is
                   class "$JAVA$java.io.FileReader"
              .

           working-storage section.
           01 ws-file        object reference cls-FileReader.
           01 ws-obj-sem     object reference cls-Script-EngineManager.
           01 ws-javascript  object reference cls-Script-Engine.
           01 ws-obj         object reference cls-object.
           01 ws-message     object reference cls-object.

           01 ws-pout        object reference cls-PrintStream.
           procedure division.
          *> setup ws-pout to be System.out object
             invoke cls-System "getout" returning ws-pout

          *> Setup a FileReader object for the external helloworld.js file
             invoke cls-FileReader "new" using
                  z"helloworld.js"
                  returning ws-file
             end-invoke

          *> Create a new script manager
             invoke cls-Script-EngineManager "new"
                 returning ws-obj-sem
             end-invoke

          *> Find the javascript engine
             invoke ws-obj-sem "getEngineByName" using
                 "JavaScript" returning ws-javascript
             end-invoke

          *> Put a variable in engine, so the javascript
          *> can use it.
             invoke ws-javascript "put" using
                z"message"
                z"Hello World from COBOL!"
             end-invoke

          *> do some javascript stuff!
             invoke ws-javascript "eval" using
                ws-file
                returning ws-obj-sem
             end-invoke

          *> get a variable in engine
             invoke ws-javascript "get" using
                z"replyMessage"
                returning ws-message
             end-invoke

          *> now display the replyMessage if it is available
             if ws-message not equal null
               invoke ws-pout "println"   using ws-message
             else
               display "Javascript did not set a replyMessage var"
             end-if
       
           
          *> cleanup code, not strickly needed for the example but
          *> its good practice, to do it.
          $if NO-FINALIZE not defined
             if ws-message not equal null
                invoke ws-message "finalize" returning ws-message
             end-if
             if ws-pout not equal null
                invoke ws-pout "finalize"    returning ws-pout
             end-if
             invoke ws-obj-sem "finalize"    returning ws-obj-sem
             invoke ws-javascript "finalize" returning ws-javascript
          $end

             stop run.
    C:\jscripting\HelloWorld3>cobol cbljscript.cbl int();
    Micro Focus Net Express V5
    Version 6.0.00059  Copyright (C) 1984-2009 Micro Focus (IP) Limited.
    URN AXCGG/AA0/00000
    * Checking complete with no errors - starting code generation
    * Generating cbljscript
    * Data:         888     Code:        2528     Literals:        1296

    C:\jscripting\HelloWorld3>runm cbljscript
    Micro Focus Net Express V6.0.00059                          
    RUN TIME ENVIRONMENT Copyright (C) 1984-2009 Micro Focus (IP) Limited.        
    URN AXCGG/AA0/00000                                                            
    Hello World from COBOL!
    Hello from javascript

    As you can see from the code above, setting up parameter is pretty easy todo but sometimes we just want to execute a function in the scripting language such as:

    function testMessage(msg)
    {
        print("testMessage : " + msg);
    }

    The ScriptEngine object that we have created to use the scripting engine may implement an optional interface called javax.script.Invocable, if the scripting engine we are using does provide this interface then a method called invokeFunction(..) can be used.

    In order to reduce the size of the COBOL code, I have coded a simple utils class in java as a simple proxy layer, the code is pretty simple but does make it easier for the COBOL to use the invokeFunction() method.

    Then from the COBOL side, we can just use the invokeFunction above.</p>

    <p>For example:</p>
    <code lang="cobol" width="800" lines="-1" nowrap="0">
           *> invoke a function with one parameter
              invoke cls-utils "invokeFunction" using
                 ws-javascript
                 z"testMessage"
                 z"Hello to function testMessage from COBOL"

    Which gives us the following output when executed.

    C:\jscripting\InvokeFunction>runm cbljscript
    Micro Focus Net Express V6.0.00059
    RUN TIME ENVIRONMENT Copyright (C) 1984-2009 Micro Focus (IP) Limited.
    URN AXCGG/AA0/00000

    testMessage : Hello to function testMessage from COBOL

    The completed example is as follows:

          *> ooctrl(+p) required for COM and Java classes
          *> ooctrl(-f) used to preserve case of method names for Java
          $set ooctrl(+p) ooctrl(-f)

           class-control.
               cls-Script-EngineManager is
                   class "$JAVA$javax.script.ScriptEngineManager"
               cls-Script-Engine is
                   class "$JAVA$javax.script.ScriptEngine"
               cls-object is
                   class "$JAVA$java.lang.Object"
               cls-System is
                   class "$JAVA$java.lang.System"    
               cls-PrintStream is
                   class "$JAVA$java.io.PrintStream"
               cls-FileReader is
                   class "$JAVA$java.io.FileReader"
               cls-Utils is
                   class "$JAVA$utils"
              .

           working-storage section.
           01 ws-file        object reference cls-FileReader.
           01 ws-obj-sem     object reference cls-Script-EngineManager.
           01 ws-javascript  object reference cls-Script-Engine.
           01 ws-message     object reference cls-object.

           01 ws-pout        object reference cls-PrintStream.
           procedure division.
          *> setup ws-pout to be System.out object
             invoke cls-System "getout" returning ws-pout

          *> Setup a FileReader object for the external helloworld.js file
             invoke cls-FileReader "new" using
                  z"helloworld.js"
                  returning ws-file
             end-invoke

          *> Create a new script manager
             invoke cls-Script-EngineManager "new"
                 returning ws-obj-sem
             end-invoke

          *> Find the javascript engine
             invoke ws-obj-sem "getEngineByName" using
                 "JavaScript" returning ws-javascript
             end-invoke

          *> do some javascript function
             invoke ws-javascript "eval" using
                ws-file
                returning ws-obj-sem
             end-invoke

          *> invoke a function with one parameter
             invoke cls-utils "invokeFunction" using
                ws-javascript
                z"testMessage"
                z"Hello to function testMessage from COBOL"
                returning ws-message
             end-invoke

          *> cleanup code, not strickly needed for the example but
          *> its good practice, to do it.
          $if NO-FINALIZE not defined
             if ws-file not equal null
                invoke ws-file "finalize" returning ws-file
             end-if
             if ws-message not equal null
                invoke ws-message "finalize" returning ws-message
              end-if
             if ws-pout not equal null
                invoke ws-pout "finalize"    returning ws-pout
             end-if
             if ws-obj-sem not equal null
                invoke ws-obj-sem "finalize"    returning ws-obj-sem
             end-if
             if ws-javascript not equal null
                invoke ws-javascript "finalize" returning ws-javascript
             end-if
          $end

             stop run.

    Conclusions: Using a Java based scripting language from COBOL is quite easy, so feel free to use it. Now which scripting language should I use…?

    Using sun.jvmstat.monitor to see active Java processes

    Posted by on December 5, 2009 Comments Off

    Monitor’ing Java processes can be achieved using the jvmstat monitor classes provided in the JVM. The documentation is a bit sketchy but with a little experimenting it can be done.

    Below is a little example that shows you how to get a list of active Java processes.. which of course can then be used for other things :-)

    Here’s the code…

    import java.net.URISyntaxException;
    import java.util.Set;

    import sun.jvmstat.monitor.*;

    public class sjps
    {
       public static void main(String[] args)
              throws MonitorException, URISyntaxException
       {
          MonitoredHost monitoredHost = MonitoredHost.getMonitoredHost("localhost");
          Set<Integer> activeVms = monitoredHost.activeVms();
          for (int psId : activeVms)
          {
             MonitoredVm monitoredVm = monitoredHost.getMonitoredVm
                       (new VmIdentifier(String.valueOf(psId)));
             String mainClass = MonitoredVmUtil.mainClass(monitoredVm, false);
             String vmVersion = MonitoredVmUtil.vmVersion(monitoredVm);
             String commandLine = MonitoredVmUtil.commandLine(monitoredVm);
             System.out.println(mainClass + " [" + psId + "]" +
                                           " using : "+vmVersion);
         System.out.println(" -> "+commandLine);
          }
       }

    }

    And to see the code running..

    $ java sjps
    sjps [865] using : 14.1-b02-90
     -> sjps
    JConsole [863] using : 14.1-b02-90
     -> sun.tools.jconsole.JConsole

    Java process id via java.lang.management

    Posted by on December 5, 2009 Comments Off

    While working on a project recently I need to find out the current process of the active running Java process (for tracing/auditing), however I never found a 100% perfect solution but did come across an acceptable solution to use the management classes to query its name, which happens to have encoding in it, so here is the quick solution:

    import java.lang.management.ManagementFactory;

    public class getpid
    {
      public static void main(String args[]) throws Exception
      {
          System.out.println("Process id : "+getProcessId());
      }

      public static long getProcessId()
      {
        String name = ManagementFactory.getRuntimeMXBean().getName();
        String[] nameBits = name.split("@");
       
        return nameBits == null ? -1 :  Long.valueOf(nameBits[0]);
      }
    }
    $ java getpid
    Process id : 377

    Type Safety and COBOL

    Posted by on November 24, 2009 Comments Off

    Having read a recent bog about COBOL and type-safety, I though I would jot down some comments.

    ANS85 COBOL is naturally is type-unsafe due as every data item being part of one memory region (or storage area), because of this it can make is difficult to talk to type-safe language such as Java or the CLR.

    However, just like any computer language it does not stay still. Object oriented features were added to COBOL, at this point in time you we were given the verbs to create 100% type safe application.

    The key to writing type safe code is the use OBJECT-REFERENCE will a TYPE and using them on in your methods and using the INVOKE verb.

    For example:

          IDENTIFICATION DIVISION.
           PROGRAM-ID.   "TypeSafeExample".
           ENVIRONMENT DIVISION.
           CONFIGURATION SECTION.
           REPOSITORY.
                  CLASS SYS-STRING AS "System.String".
           DATA DIVISION.
           WORKING-STORAGE SECTION.
           01 hello-world-string    OBJECT REFERENCE SYS-STRING.
           
           PROCEDURE DIVISION.    
              SET hello-world-string TO "Hello World"
              DISPLAY hello-world-string
              STOP RUN.

    The use of COBOL pictures can still be used, however for easy interop with other type-safe languages you really have to stick to the right types for your target environment when exposing your COBOL program to the other languages, this means if you are creating classes, the method to be consumed by other languages should use standard types, for .Net/CLR applications the use of CLS-COMPLIANT types is the right approach. For JVM applications, keep to the “core” java.lang types.

    Keep to these simple rules and COBOL will happy interop with type-safe languages. :-)