trans = new JoltTransaction(timeout, session)

/* Copyright 1999 Oracle Systems, Inc.  All Rights Reserved */
import bea.jolt.*;
public class SimXfer
{
    public static void main (String[] args)
    {
        JoltSession session;
        JoltSessionAttributes sattr;
        JoltRemoteService withdrawal;
        JoltRemoteService deposit;
        JoltTransaction trans;
        String userName=null;
        String userPassword=null;
        String appPassword=null;
        String userRole=”myapp”;

        sattr = new JoltSessionAttributes(); 					
        sattr.setString(sattr.APPADDRESS, “//bluefish:8501”);

        switch (sattr.checkAuthenticationLevel())		 
        {
        case JoltSessionAttributes.NOAUTH:
            System.out.println(“NOAUTH\n”);
            break;
        case JoltSessionAttributes.APPASSWORD:
            appPassword = “appPassword”;
            break;
        case JoltSessionAttributes.USRPASSWORD:
             userName = “myname”; 
            userPassword = “mysecret”;
            appPassword = “appPassword”;
            break;
        }
        sattr.setInt(sattr.IDLETIMEOUT, 300);
        session = new JoltSession(sattr, userName, userRole,
        userPassword, appPassword);
        // Simulate a transfer
        withdrawal = new JoltRemoteService(“WITHDRAWAL”, session);
        deposit = new JoltRemoteService(“DEPOSIT”, session);

        withdrawal.addInt(“ACCOUNT_ID”, 100000);
        withdrawal.addString(“SAMOUNT”, “100.00”);

        // Begin the transaction w/ a 5 sec timeout
        trans = new JoltTransaction(5, session);
        try
        {
            withdrawal.call(trans);
        }

        catch (ApplicationException e)
        {
            e.printStackTrace();
            // This service uses the STATLIN field to report errors
            // back to the client application.
            System.err.println(withdrawal.getStringDef(“STATLIN”,”NO 
            STATLIN”));
            System.exit(1);
        }

        String wbal = withdrawal.getStringDef(“SBALANCE”, “$-1.0”);

        // remove leading “$” before converting string to float
        float w = Float.valueOf(wbal.substring(1)).floatValue();
        if (w < 0.0)
        {
            System.err.println(“Insufficient funds”);
            trans.rollback();
            System.exit(1);
        }
        else            // now attempt to deposit/transfer the funds
        {
            deposit.addInt(“ACCOUNT_ID”, 100001);
            deposit.addString(“SAMOUNT”, “100.00”);

            deposit.call(trans);
            String dbal = deposit.getStringDef(“SBALANCE”, “-1.0”);
            trans.commit();

            System.out.println(“Successful withdrawal”);
            System.out.println(“New balance is: “ + wbal);

            System.out.println(“Successful deposit”);
            System.out.println(“New balance is: “ + dbal);
        }

        session.endSession();
        System.exit(0);
        } // end main
    } // end SimXfer

/* Copyright 1996 Oracle Systems, Inc.  All Rights Reserved */
import bea.jolt.*;
public class ToUpper
  {
    public static void main (String[] args)
    {
        JoltSession            session;
        JoltSessionAttributes  sattr;
        JoltRemoteService      toupper;
        JoltTransaction        trans;
        String userName=null;
        String userPassword=null;
        String appPassword=null;
        String userRole=”myapp”;
        String outstr;

        sattr = new JoltSessionAttributes();
        sattr.setString(sattr.APPADDRESS, “//myhost:8501”);

        switch (sattr.checkAuthenticationLevel())
        {
        case JoltSessionAttributes.NOAUTH:
            break;
        case JoltSessionAttributes.APPASSWORD:
            appPassword = “appPassword”;
            break;
        case JoltSessionAttributes.USRPASSWORD:
            userName = “myname”; 
            userPassword = “mysecret”;
            appPassword = “appPassword”;
            break;
        }
        sattr.setInt(sattr.IDLETIMEOUT, 300);
        session = new JoltSession(sattr, userName, userRole, 
        userPassword, appPassword);
        toupper = new JoltRemoteService (“TOUPPER”, session);
        toupper.setString(“STRING”, “hello world”);
        toupper.call(null);
        outstr = toupper.getStringDef(“STRING”, null);
        if (outstr != null)
            System.out.println(outstr);

        session.endSession();
                  System.exit(0);
    } // end main
  } // end ToUpper

/* Copyright 1996 Oracle Systems, Inc. All Rights Reserved */

  /* This code fragment illustrates how Jolt works with a service  
   * whose buffer type is CARRAY.
   */

import java.io.*;
import bea.jolt.*;
class ...
{
    ...
    public void tryOnCARRAY()
    {
        byte data[];
        JoltRemoteService csvc;
        DataInputStream din;
        DataOutputStream dout;
        ByteArrayInputStream bin;
        ByteArrayOutputStream bout;
        /*
         * Use java.io.DataOutputStream to put data into a byte array
         */
        bout = new ByteArrayOutputStream(512);
        dout = new DataOutputStream(bout);
        dout.writeInt(100);
        dout.writeFloat((float) 300.00);
        dout.writeUTF("Hello World");
        dout.writeShort((short) 88);
        /*
         * Copy the byte array into a new byte array "data".  Then
         * issue the Jolt remote service call.
         */
        data = bout.toByteArray();
        csvc = new JoltRemoteService("ECHO", session);
        csvc.setBytes("CARRAY", data, data.length);
        csvc.call(null);
        /*
         * Get the result from JoltRemoteService object and use
         * java.io.DataInputStream to extract each individual value
         * from the byte array.
         */
        data = csvc.getBytesDef("CARRAY", null);
        if (data != null)
        {
            bin = new ByteArrayInputStream(data);
            din = new DataInputStream(bin);
            System.out.println(din.readInt());
            System.out.println(din.readFloat());
            System.out.println(din.readUTF());
            System.out.println(din.readShort());
        }
    }
}

/* Copyright 1997 Oracle Systems, Inc. All Rights Reserved */

import bea.jolt.*;
class ...
{
    ...
    public void tryOnFml ()
    {
        JoltRemoteService passFml;
        String outputString;
        int outputInt;
        float outputFloat;
                 ... 
        passFml = new JoltRemoteService("PASSFML",session); 
        passFml.setString("INPUTSTRING", "John");
        passFml.setInt("INPUTINT", 67);
        passFml.setFloat("INPUTFLOAT", (float)12.0);
        passFml.call(null);
        outputString = passFml.getStringDef("OUTPUTSTRING", null);
        outputInt = passFml.getIntDef("OUTPUTINT", -1);
        outputFloat = passFml.getFloatDef("OUTPUTFLOAT", (float)-1.0);
        System.out.print("String =" + outputString);
        System.out.print(" Int =" + outputInt);
        System.out.println(" Float =" + outputFloat);
        }
}

#
# FML field definition table
#
*base    4100
INPUTSTRING   1    string
INPUTINT      2    long
INPUTFLOAT    3    float
OUTPUTSTRING  4    string
OUTPUTINT     5    long
OUTPUTFLOAT   	6    float

/*

 * tryOnFml.c 
 *
 * Copyright (c) 1997 Oracle Systems, Inc. All rights reserved
 *
 * Contains the PASSFML Oracle Tuxedo server.
 * 
 */
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <malloc.h>
#include <math.h>
#include <string.h>
#include <fml.h>
#include <fml32.h>
#include <Usysflds.h>
#include <atmi.h>
#include <userlog.h>
#include "tryOnFml.f16.h"
/* 
 * PASSFML service reads in a input fml buffer and outputs a fml buffer.
 */
void
PASSFML( TPSVCINFO *rqst )
{
	FLDLEN	len;
	FBFR	*svcinfo = (FBFR *) rqst->data;
	char	inputString[256];
	long	inputInt;
	float	inputFloat;
	FBFR	*fml_ptr;
	int	rt;
	if (Fget(svcinfo, INPUTSTRING, 0, inputString, &len) < 0) {
		(void)userlog("Fget of INPUTSTRING failed %s",
			Fstrerror(Ferror));
		tpreturn(TPFAIL, 0, rqst->data, 0L, 0);
	}
	if (Fget(svcinfo, INPUTINT, 0, (char *) &inputInt, &len) < 0) {
		(void)userlog("Fget of INPUTINT failed %s",Fstrerror(Ferror));
		tpreturn(TPFAIL, 0, rqst->data, 0L, 0);
	}
	if (Fget(svcinfo, INPUTFLOAT, 0, (char *) &inputFloat, &len) < 0) {
		(void)userlog("Fget of INPUTFLOAT failed %s",
			Fstrerror(Ferror));
		tpreturn(TPFAIL, 0, rqst->data, 0L, 0);
	}
	/* We could just pass the FML buffer back as is, put lets	*/
	/* store it into another FML buffer and pass it back.		*/
	if ((fml_ptr = (FBFR *)tpalloc("FML",NULL,rqst->len))==(FBFR *)NULL) {
		(void)userlog("tpalloc failed in PASSFML %s", 
			tpstrerror(tperrno));
		tpreturn(TPFAIL, 0, rqst->data, 0L, 0);
	}
	if(Fadd(fml_ptr, OUTPUTSTRING, inputString, (FLDLEN)0) == -1) {
		userlog("Fadd failed with error: %s", Fstrerror(Ferror));
		tpfree((char *)fml_ptr);
		tpreturn(TPFAIL, 0, NULL, 0L, 0);
        }
	if(Fadd(fml_ptr, OUTPUTINT, (char *)&inputInt, (FLDLEN)0) == -1) {
		userlog("Fadd failed with error: %s", Fstrerror(Ferror));
		tpfree((char *)fml_ptr);
		tpreturn(TPFAIL, 0, NULL, 0L, 0);
        }
	if(Fadd(fml_ptr, OUTPUTFLOAT, (char *)&inputFloat, (FLDLEN)0) == -1) {
		userlog("Fadd failed with error: %d\n", Fstrerror(Ferror));
		tpfree((char *)fml_ptr);
		tpreturn(TPFAIL, 0, NULL, 0L, 0);
        }
	tpreturn(TPSUCCESS, 0, (char *)fml_ptr, 0L, 0);
}

/* Copyright 1997 Oracle Systems, Inc. All Rights Reserved */
/*
 * This code fragment illustrates how Jolt works with a service whose buffer
 * type is VIEW. 
 */
import bea.jolt.*;
class ...
{
	...	
	public void simpview ()
	{
		JoltRemoteService ViewSvc;
		String outString;
		int outInt;
		float outFloat;
		// Create a Jolt Service for the Oracle Tuxedo service "SIMPVIEW"
		ViewSvc = new JoltRemoteService("SIMPVIEW",session); 
		// Set the input parameters required for SIMPVIEW
		ViewSvc.setString("inString", "John");
		ViewSvc.setInt("inInt", 10);
		ViewSvc.setFloat("inFloat", (float)10.0);
		// Call the service. No transaction required, so pass
		// a "null" parameter
		ViewSvc.call(null);
		// Process the results
		outString = ViewSvc.getStringDef("outString", null);
		outInt = ViewSvc.getIntDef("outInt", -1);
		outFloat = ViewSvc.getFloatDef("outFloat", (float)-1.0);
		// And display them...
		System.out.print("outString=" + outString + ",");
		System.out.print("outInt=" + outInt + ",");
		System.out.println("outFloat=" + outFloat);
	}
}

#
# VIEW for SIMPVIEW. This view is used for both input and output. The
# service could also have used separate input and output views.
# The first 3 params are input params, the second 3 are outputs.
#
VIEW SimpView
$
#type	cname		fbname	count	flag	size	null
string	inString		-	1	-	32	-
long	inInt		-	1	-	-	-
float	inFloat		-	1	-	-	-
string	outString		-	1	-	32	-	
long	outInt		-	1	-	-	-
float	outFloat		-	1	-	-	-
END

/*
 * SIMPVIEW.c 
 *
 * Copyright (c) 1997 Oracle Systems, Inc.  All rights reserved
 *
 * Contains the SIMPVIEW Oracle Tuxedo server.
 * 
 */
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <malloc.h>
#include <math.h>
#include <string.h>
#include <fml.h>
#include <fml32.h>
#include <Usysflds.h>
#include <atmi.h>
#include <userlog.h>
#include "simpview.h"
/*
 * Contents of simpview.h.
 *
 *struct SimpView {
 *
 *	char	inString[32];
 *	long	inInt;
 *	float	inFloat;
 *	char	outString[32];
 *	long	outInt;
 *	float	outFloat;
 *};
 */
/* 
 *  service reads in a input view buffer and outputs a view buffer.
 */
void
SIMPVIEW( TPSVCINFO *rqst )
{
	/*
	 * get the structure (VIEWSVC) from the TPSVCINFO structure
	 */
	struct SimpView	*svcinfo = (struct SimpView *) rqst->data;
	/*
	 * print the input params to the UserLog. Note there is
	 * no error checking here. Normally a SERVER would perform
	 * some validation of input and return TPFAIL if the input
	 * is not correct.
	 */
	(void)userlog("SIMPVIEW: InString=%s,InInt=%d,InFloat=%f",
		svcinfo->inString, svcinfo->inInt, svcinfo->inFloat);
	/*
	 * Populate the output fields and send them back to the caller
	 */
	
	strcpy (svcinfo->outString, "Return from SIMPVIEW");
	svcinfo->outInt = 100;
	svcinfo->outFloat = (float) 100.00;
	/*
	 * If there was an error, return TPFAIL
	 * tpreturn(TPFAIL, ErrorCode, (char *)svcinfo, sizeof (*svcinfo), 0);
	 */
	tpreturn(TPSUCCESS, 0, (char *)svcinfo, sizeof (*svcinfo), 0);
}

/* Copyright 2001 Oracle Systems, Inc. All Rights Reserved */
/*
 * This code fragment illustrates how Jolt works with a service whose buffer
 * type is XML. 
 */

import java.io.*;
import java.lang.*;
import bea.jolt.*;

public class xmldoc {

    	public static void main (String[] args) {
        		JoltSessionAttributes  sattr;
        		JoltSession            session;
        		JoltRemoteService      echo_xml;

		String inString = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><ORDER><HEADER DATE=\"05/13/1999\" ORDERNO=\"22345\"/><COMPANY>ACME</COMPANY><LINE><ITEM MODEL=\"Pabc\" QUANTITY=\"5\">LAPTOP</ITEM></LINE><LINE><ITEM MODEL=\"P500\" QUANTITY=\"15\">LAPTOP</ITEM></LINE></ORDER>";

        		byte data[];
        		DataInputStream din;
        		DataOutputStream dout;
        		ByteArrayInputStream bin;
        		ByteArrayOutputStream bout;

        		byte odata[];
        		String outString = null;
        		String appAddress = null;

        		//...Create Jolt Session 

        		try {
            			/*
           		 	 * Use java.io.DataOutputStream to put data 
            			 * into a byte array
           		 	 */
            			bout = new ByteArrayOutputStream(inString.length());
            			dout = new DataOutputStream(bout);
            			dout.writeBytes(inString);

			            /*
           		 	 * Copy the byte array into a new byte array "data".  
            			 * Then issue the Jolt remote service call.
            	 */
            			data = bout.toByteArray();
        		} catch (Exception e) {
            			System.out.println("toByteArray error");
            			return;
        		}

        		try {
            			echo_xml = new JoltRemoteService("ECHO_XML", session); 
            			System.out.println("JoltRemoteService Created");
            			echo_xml.setBytes("XML", data, data.length);
        		} catch (Exception e) {
            			System.out.println("RemoteService call error" + e);
            			return;
        		}

        		echo_xml.call(null);
        		System.out.println("Service Call Returned");
        		odata = echo_xml.getBytesDef("XML", null);

        		try {
            			System.out.println("Return String is:" + new String(odata));
        		} catch (Exception e) {
            			System.err.println("getByteDef Error");
        		}
    	}
}

// end of class

Thread.currentThread.yield();

/* Copyright 1996 Oracle Systems, Inc.  All Rights Reserved */
import bea.jolt.*;
public class ThreadBank
{
   public static void main (String [] args)
   {
      JoltSession session;
      try
      {
         JoltSessionAttributes dattr;
         String userName = null;
         String userPasswd = null;
         String appPasswd = null;
         String userRole = null;

         // fill in attributes required
         dattr = new JoltSessionAttributes();
         dattr.setString(dattr.APPADDRESS,”//bluefish:8501”);

         // instantiate domain
         // check authentication level
         switch (dattr.checkAuthenticationLevel())
         {

         case JoltSessionAttributes.NOAUTH:
              System.out.println(“NOAUTH\n”);
              break;
         case JoltSessionAttributes.APPASSWORD:
              appPasswd = “myAppPasswd”;
              break;
         case JoltSessionAttributes.USRPASSWORD:
              userName = “myName”;
              userPasswd = “mySecret”;
              appPasswd = “myAppPasswd”;
              break;
   }
         dattr.setInt(dattr.IDLETIMEOUT, 60);
         session = new JoltSession (dattr, userName, userRole,
                                    userPasswd, appPasswd);
         T1 t1 = new T1 (session);
         T2 t2 = new T2 (session);

         t1.start();
         t2.start();

         Thread.currentThread().yield();
         try
         {
            while (t1.isAlive() && t2.isAlive())
            {
               Thread.currentThread().sleep(1000);
               
            }
         }
         catch (InterruptedException e)
         {
            System.err.println(e);
            if (t2.isAlive())
            {
               System.out.println(“job 2 is still alive”);
               try
               {
                  Thread.currentThread().sleep(1000);
               }
               catch (InterruptedException e1)
               {   
                  System.err.println(e1);
               }
            }
            else if (t1.isAlive())
            {   System.out.println(“job1 is still alive”);
               try
               {
                  Thread.currentThread().sleep(1000);
               }
               catch (InterruptedException e1)
               {
                  System.err.println(e1);
               }
            }
         }
         session.endSession();
      }
      catch (SessionException e)
      {
         System.err.println(e);
      }
      finally
      {
         System.out.println(“normal ThreadBank term”);
      }
   }
}

class T1 extends Thread
{
   JoltSession j_session;
   JoltRemoteService j_withdrawal;

   public T1 (JoltSession session)
   {
      j_session=session;
      j_withdrawal= new JoltRemoteService(“WITHDRAWAL”,j_session);
   }
   public void run() 
   {
      j_withdrawal.addInt(“ACCOUNT_ID”,10001);
      j_withdrawal.addString(“SAMOUNT”,”100.00”);
      try
      {
         System.out.println(“Initiating Withdrawal from account 10001”);
         j_withdrawal.call(null);
         String W = j_withdrawal.getStringDef(“SBALANCE”,”-1.0”);
         System.out.println(“-->Withdrawal Balance: “ + W);
      }
      catch (ApplicationException e)
      {
         e.printStackTrace();
         System.err.println(e);
      }
   }
}

class T2 extends Thread
{
   JoltSession j_session;
   JoltRemoteService j_deposit;

   public T2 (JoltSession session)
   {
      j_session=session;
      j_deposit= new JoltRemoteService(“DEPOSIT”,j_session);
   }
   public void run() 
   {
      j_deposit.addInt(“ACCOUNT_ID”,10000);
      j_deposit.addString(“SAMOUNT”,”100.00”);
      try
      {
         System.out.println(“Initiating Deposit from account 10000”);
         j_deposit.call(null);
         String D = j_deposit.getStringDef(“SBALANCE”,”-1.0”);
         System.out.println(“-->Deposit Balance: “ + D);
      }
      catch (ApplicationException e)
      {
         e.printStackTrace();
         System.err.println(e);
      }
   }
}

getIntDef ("ACCOUNT_ID", -1);

getStringDef ("STRING", null);
getBytesDef ("CARRAY", null);

class EventSession extends JoltSession
{
    public EventSession( JoltSessionAttributes attr, String user,
                         String role, String upass, String apass )
    {
           super(attr, user, role, upass, apass);
    }
    /**
    * Override the default unsolicited message handler.
    * @param reply a place holder for the unsolicited message
    * @see bea.jolt.JoltReply
    */
    public void onReply( JoltReply reply )
    {
        // Print out the STRING buffer type message which contains
        // only one field; the field name must be "STRING".  If the
        // message uses CARRAY buffer type, the field name must be
        // "CARRAY".  Otherwise, the field names must conform to the
        // elements in FML or VIEW.

        JoltMessage msg = (JoltMessage) reply.getMessage();
        System.out.println(msg.getStringDef("STRING", "No Msg"));
    }
    public static void main( Strings args[] )
    {
        JoltUserEvent  unsolEvent;
        JoltUserEvent   helloEvent;
        EventSession    session;
        ...

        // Instantiate my session object which can print out the
        // unsolicited messages.  Then subscribe to HELLO event
        // and Unsolicited Notification which both use STRING
        // buffer type for the unsolicited messages.

        session = new EventSession(...);

        helloEvent = new JoltUserEvent("HELLO", null, session);
        unsolEvent = new JoltUserEvent(JoltUserEvent.UNSOLMSG, null,
                                       session);
        ...
        // Unsubscribe the HELLO event and unsolicited notification.
        helloEvent.unsubscribe();
        unsolEvent.unsubscribe();
    }
}

/* Copyright 1999 Oracle Systems, Inc. All Rights Reserved */
import java.net.*;
import java.io.*;
import bea.jolt.*;
/*
 * This is a Jolt sample program that illustrates how to reuse the
 * JoltRemoteService after each invocation.
 */
class reuseSample
{
    private static JoltSession s_session;
    static void init( String host, short port )
    {
        /* Prepare to connect to the Tuxedo domain.  */
        JoltSessionAttributes attr = new JoltSessionAttributes();
        attr.setString(attr.APPADDRESS,”//”+ host+”:” + port);

        String username = null;
        String userrole = “sw-developer”;
        String applpasswd = null;
        String userpasswd = null;

        /* Check what authentication level has been set. */
        switch (attr.checkAuthenticationLevel())
        {
            case JoltSessionAttributes.NOAUTH:
                break;
            case JoltSessionAttributes.APPASSWORD:
                applpasswd = “secret8”;
                break;
            case JoltSessionAttributes.USRPASSWORD:
                username = “myName”;
                userpasswd = “BEA#1”;
                applpasswd = “secret8”;
                break;
        }

        /* Logon now without any idle timeout (0). */
        /* The network connection is retained until logoff. */
        attr.setInt(attr.IDLETIMEOUT, 0);
        s_session = new JoltSession(attr, username, userrole,
        userpasswd, applpasswd);
    }

    public static void main( String args[] )
    {
        String host;
        short  port;
        JoltRemoteService svc;

        if (args.length != 2)
        {
            System.err.println(“Usage: reuseSample host port”);
            System.exit(1);
        }

        /* Get the host name and port number for initialization. */
        host = args[0];
        port = (short)Integer.parseInt(args[1]);

        init(host, port);

        /* Get the object reference to the DELREC service.  This
         * service has no output parameters, but has only one input
         * parameter.
         */
        svc = new JoltRemoteService(“DELREC”, s_session);
        try
        {
            /* Set input parameter REPNAME. */
            svc.addString(“REPNAME”, “Record1”);
            svc.call(null);
            /* Change the input parameter before reusing it */
            svc.setString(“REPNAME”, “Record2”);
            svc.call(null);

            /* Simply discard all input parameters */
            svc.clear();
            svc.addString(“REPNAME”, “Record3”);
            svc.call(null);
        }
        catch (ApplicationException e)
        {
            System.err.println(“Service DELREC failed: “+
            e.getMessage()+” “+ svc.getStringDef(“MESSAGE”, null));
        }

        /* Logoff now and get rid of the object. */
        s_session.endSession();
    }
} 

/* Copyright 1999 Oracle Systems, Inc. All Rights Reserved */

import java.net.*;
import java.io.*;
import bea.jolt.*;

/*
 * This Jolt sample code fragment illustrates how to customize
 * JoltRemoteService. It uses the Java language “extends” mechanism 
 */
class TransferService extends JoltRemoteService
{
    public String  fromBal;
    public String  toBal;

    public TransferService( JoltSession session )
    {
        super(“TRANSFER”, session);
    }

    public String doxfer( int fromAcctNum, int toAcctNum, String amount )
    {
        /* Clear any previous input parameters */
        this.clear();

        /* Set the input parameters */
        this.setIntItem(“ACCOUNT_ID”, 0, fromAcctNum);
        this.setIntItem(“ACCOUNT_ID”, 1, toAcctNum);
        this.setString(“SAMOUNT”, amount );

        try
        {
            /* Invoke the transfer service. */
            this.call(null);

            /* Get the output parameters */
            fromBal = this.getStringItemDef(“SBALANCE”, 0, null);
            if (fromBal == null)
                return “No balance from Account “ + 
                fromAcctNum;
            toBal = this.getStringItemDef(“SBALANCE”, 1, null);
            if (toBal == null)
                return “No balance from Account “ + toAcctNum;
            return null;
        }
        catch (ApplicationException e)
        {
            /* The transaction failed, return the reason */
            return this.getStringDef(“STATLIN”, “Unknown reason”);
        }
    }
}

class extendSample
{
    public static void main( String args[] )
    {
        JoltSession s_session;
        String   host;
        short    port;
        TransferService xfer;
        String   failure;

        if (args.length != 2)
        {
            System.err.println(“Usage: reuseSample host port”);
        System.exit(1);
        }

        /* Get the host name and port number for initialization. */
        host = args[0];
        port = (short)Integer.parseInt(args[1]);

        /* Prepare to connect to the Tuxedo domain.  */
        JoltSessionAttributes attr = new JoltSessionAttributes();
        attr.setString(attr.APPADDRESS,”//”+ host+”:” + port);

        String username = null;
        String userrole = “sw-developer”;
        String applpasswd = null;
        String userpasswd = null;

        /* Check what authentication level has been set. */
        switch (attr.checkAuthenticationLevel())
        {
            case JoltSessionAttributes.NOAUTH:
                break;
            case JoltSessionAttributes.APPASSWORD:
                applpasswd = “secret8”;
                break;
            case JoltSessionAttributes.USRPASSWORD:
                username = “myName”;
                userpasswd = “BEA#1”;
                applpasswd = “secret8”;
                break;
        }

        /* Logon now without any idle timeout (0). */
        /* The network connection is retained until logoff. */
        attr.setInt(attr.IDLETIMEOUT, 0);
        s_session = new JoltSession(attr, username, userrole,
        userpasswd, applpasswd);

        /*
         * TransferService extends from JoltRemoteService and uses the
         * standard Oracle Tuxedo BankApp TRANSFER service.  We invoke this
         * service twice with different parameters.  Note, we assume
         * that “s_session” is initialized somewhere before.
         */

        xfer = new TransferService(s_session);
        if ((failure = xfer.doxfer(10000, 10001, “500.00”)) != null)
            System.err.println(“Tranasaction failed: “ + failure);
        else
        {
            System.out.println(“Transaction is done.”);
            System.out.println(“From Acct Balance: “+xfer.fromBal);
            System.out.println(“  To Acct Balance: “+xfer.toBal);
        }

        if ((failure = xfer.doxfer(51334, 40343, “$123.25”)) != null)
            System.err.println(“Tranasaction failed: “ + failure);
        else
        {
            System.out.println(“Transaction is done.”);
            System.out.println(“From Acct Balance: “+xfer.fromBal);
            System.out.println(“  To Acct Balance: “+xfer.toBal);
        }
} 
}

<applet code=“applet_name.class”> </applet>

<html-dir>/classes/bea/jolt

    /export/html/
        |___ classes/
        |    |_____ bea/
        |    |    |______ jolt/
        |    |          |_____ JoltSessionAttributes.class
        |    |          |_____ JoltRemoteServices.class
        |    |          |_____ ...
        |    |_____ mycompany/
        |         |________ app.class
        |___ ex1.html
        |___ ex2.html

<applet codebase=“classes” code=mycompany.app.class width=400 height=200>

import java.util.*;
import bea.jolt.*;

public class simpcl extends Object {

    private String           userName      = null;

    private String           userRole      = null;

    private String           appPassword   = null;

    private String           userPassword  = null;

    private JoltSessionAttributes attr     = null;

    private JoltSession          session   = null;

    private JoltRemoteService    toupper   = null;

    private JoltTransaction      trans     = null;

    // JSL is configured with '-s 5555'

    // the communication between jolt client and JSH will use SSL

    private String               address   = new String('//cerebrum:5555');

    public static void main(String args[]) {

        simpcl c = new simpcl();

        c.doTest();

    }

    public void doTest() {

        attr = new JoltSessionAttributes();

        // adding these session attribute

        attr.setString(attr.APPADDRESS, address);

        attr.setString(attr.TRUSTSTORE,'c:\\samples\\samplecacerts');

        attr.setString(attr.KEYSTORE, 'c:\\samples\\client\\testkeys');

        // Only key store and key will be protected by passphrase in this sample.

        // But optionly the trust store can also be protected by a passphrase

        // although it is not in this sample.

        attr.setString(attr.KSPASSPHRASE, 'passphrase');

        attr.setString(attr.KEYPASSPHRASE, 'passphrase');

        attr.setInt(attr.IDLETIMEOUT, 300);

        userName = 'juser';

        userRole = 'JUSER';

        userPassword = 'abcd';

        appPassword = 'abcd';

        session = new JoltSession(attr, userName, userRole, userPassword, 

                              appPassword);

        // access a Tuxedo TOUPPER service

        toupper = new JoltRemoteService('TOUPPER', session);

        toupper.addString('STRING', 'string');

        trans = new JoltTransaction(60, session);

        try {

            toupper.call(trans);

        } catch (ApplicationException ae) {

            ae.printStackTrace();

            System.exit(1);

        }

        String retString = toupper.getStringDef('STRING', null);

        trans.commit();

        System.out.println(' returned: ' + retString);

        session.endSession();

        return;

    }

}