TAFJ-R15

1
TAFJ-R15
2
 The Temenos enterprise architecture consists of six frameworks.
Interaction Framework – Framework that separates user agent from banking
capability. It facilitates communication between any user agent (viz.,TCIB, TCMB,
Browser Replacement, an app developed by the bank in the future) and many sources
at the back end (viz., T24, TAP, WM or any product or data source that Temenos
acquires/adds in the future or even a 3rd Party)
Component Framework – Framework to componentize T24 into independent units
with quality benefits, ability to do online updates, incremental upgrades and reuse
Integration Framework – Framework for multi-point integration. It is event based and
is used to implement interfaces to and from Temenos products at the business event
level without writing code.
Platform Framework – Framework to push platform functionalities like threading,
memory management, caching, locking, database pooling etc out of T24 into the JEE
server/database. The platform framework enables the same source code to run as a
native application in Java and C called TAFJ and TAFC
Data Framework – Framework aimed at stopping T24 database growing as
transactions accrue, thereby improving throughput. The live OLTP database size is
expected to reduce by 70% with DLM (data life cycle management). Over time the
data framework will separate the transactional data model optimized for OLTP from
the reporting data model optimized for OLAP.
Design Framework – Framework to separate the design time and the runtime.
Versions, Enquiries, Local references, Composite screens, menus etc are design time
artifacts and the design framework facilitates separating the creation of these artifacts
and storage from the runtime. These artifacts are called as Models. The design
framework is based on MDD (model driven design)

TAFJ-R15
3
 • TAFJ (Temenos Application Framework Java) is our proprietary runtime and
compiler for jBC code, written in 100% java. It allows compiling and running jBC
programs on Java. jBC code is parsed by the TAFJ parser and compiled by javac
compiler and translated into equivalent Java classes. The java compliant files
generated can then be run in a JVM taking the full advantage of Java functionality
like portability, platform independence etc. This also enables T24 to harness the
full functionality of J2EE application servers like connection pooling, threading,
security etc.
• TAFJ manages the connectivity on JDBC compliant databases like Oracle,
Microsoft SQL Server, DB2, DB2 – zOS, and for development purposes on H2.
• T24 on TAFJ R15 runs on JDK 1.6 and above

TAFJ-R15
4
 The TAFJ T24 architecture can be understood from this diagram
• Any T24 source code(*.b) can be compiled into java classes(*.class) on TAFJ. The
entire T24 source code is compiled and packaged into jar files and deployed on a
J2EE server. When a request comes to T24, the required .class files are executed
on the TAFJ runtime. TAFJ uses JDBC drivers to connect to JDBC compliant
databases like H2, Oracle, SQL server, DB2, DB2-zOS.
• TAFJ runtime comes with several useful and easy to use tools to manage the
runtime and database. For e.g., to import data from a jBase database into oracle
database there is a tool called DBImport.
• All the runtime configurations (for eg, the URL of the database to connect to,
compiler settings, the location of the runtime user directory etc. ) are specified and
managed using property files. These are simple text files and can be changed
easily. To connect to a different database, all that we need to do is change the
database property values in the property file and the associated TAFJ project will
behave accordingly.
• TAFJ uses log4J loggers and maintains extensive logs.
• Unlike TAFC, TAFJ makes use of the OS print manager and the JVM print
mechanism and hence it is easy to configure printers. TAFJ does not have a
spooler of its own like the TAFC spooler.
• TAFJ provides a lock manager (like the jdls in TAFC) for database lock
management.
• TAFJ also has the capability of redirecting all in and out streams to a remote client
console.
Note: *.b – all basic routines in TAFJ should have a ‘.b’ extension. It is not mandatory
currently, but will get enforced shortly.

TAFJ-R15
5
 The TAFJ workflow is as follows :

The developer writes code for T24 using jBC programming language(alternatively
referred as Basic in this course collaterals) on Design Studio. This is enabled by the
eclipse TAFJ plugin. The TAFJ lexer-parser-tree walker translates standard jBC code
into equivalent Java code and generates the source code file(.java), which is then
compiled into a java compliant bytecode(.class) using the standard javac compiler.
The .java files are deleted after compilation. The bytecode can be run on any JVM thus
making T24 platform independent. Local T24 developments can be done in pure Java
too.

[Note: To execute T24 on TAFJ, we need only the jre. However if you need the
compiler, then you must have JDK in your machine. JDK = JRE + Compiler. ]

TAFJ-R15
6
TAFJ-R15
7
 If we compile T24 on TAFC on a windows platform then we can execute it only on
Windows. (even on Z/OS) However Java programs are popularly known as write once
and execute anywhere. That makes T24 on TAFJ as completely platform independent.
A platform is the hardware and software environment in which the program runs. Any
program that needs to be executed on a platform must be converted into machine
instructions understandable by that platform. When developers write T24 programs on
TAFJ and compile it, the code is not directly converted into machine instructions but it
is compiled into ByteCode. Bytecode is not machine instructions that any platform like
Windows, Unix will understand it directly. This Bytecode is understood by Java made
Virtual machines. Java Virtual Machines (JVM) interprets the Bytecode into machine
specific instructions so that platform can understand it. Java Virtual Machine (JVM)
plays a key role in making the Bytecode understandable to any underlying platform
thus makes the Bytecode platform independent. Thus a T24 compiled on Oracle JDK
on Windows will seamlessly run on an IBM JVM on Unix
Thus,
• Java is a platform independent.
• Java programs are compiled into Bytecode which are platform independent.
• Bytecode are executed on Java Virtual Machines (JVM).
• Java Virtual Machine (JVM) is platform dependent.
• JVM needs to be pre-installed on the machine for executing java program.
• There are different version of JVM available in the market to support variety of
platform.

TAFJ-R15
8
 TAFJ uses only free and open source software's for all 3rd party requirements, like H2,
jBoss, JDK, eclipse etc. The competitive advantage that an OSS gives by allowing
customization of code to suit our company’s needs is a significant reason for using
them in addition to the low cost of ownership. A T24 on TAFC requires renewal of T24
as well as MSVC licenses, whereas Java is free. Support for other contemporary
market technologies is easier with TAFJ rather than TAFC. For example lets presume
a client wants to use MySQL, another open source database instead of the officially
supported ones. On a TAFC runtime, we have Direct connect drivers (DCD) for Oracle,
SQL Server and DB2. Extensive programming effort is required to newly create a DCD
for MySQL. Whereas on TAFJ, since we use JDBC drivers, its only a matter of very
few lines of code to write for performance improvement.

TAFJ-R15
9
 COB and services execute in a multiprocessing fashion on a T24 Application Server
i.e., each agent executes as a distinct process. If for some reason, the Agents
Required is set to 50 or 100 by mistake, 100 processes will start and this will cause
T24 application to crash. This will in turn crash the Application server(AS).
TAFJ uses the full functionality of J2EE, since the T24 application runs inside the JVM.
To execute COB on an AS, it uses java multithreading where each tSA executes as a
distinct thread instead of as a process. The resource overhead is definitely far less in a
multithreading environment as against a multiprocessing environment. Though the no
of agents required is 50 in the e.g., shown, since the maximum thread that can be
started in the AS is set to 20, the AS will not initiate more than 20 threads. Thus
resource management is done by the AS. Even if the T24 on TAFJ crashes for unlikely
reasons, the application server will not crash as T24 is running inside a JVM.

TAFJ-R15
10
 Clustering Application server is a very common implementation for performance. T24
on TAFJ is deployed inside an Application server like jBoss, Websphere or Weblogic.
Hence when the application server is clustered, T24 application is also automatically
clustered and benefits from it. However in the case of TAFC, since T24 is outside an
AS, Application server clustering does not entail T24 clustering.

TAFJ-R15
11
TAFJ-R15
12
 What’s in it for a developer ?

 Development on a market standard IDE

 Excellent debugger for efficient and faster bug fixing

 Help is just a click away …. Google your queries. For e.g. if you want
to configure a Printer on Linux, simply Google CUPS. This is so because all
software's used are contemporary market standards.

TAFJ-R15
13
 You will learn how to install TAFJ
a. From a Dev Image
b. A setup from scratch

TAFJ-R15
14
 On extracting the Dev Image, a TAFJ area is created automatically. Ensure the dev
image is extracted in the D: drive since the scripts in the area are hard coded to this
drive. A folder called Temenos gets created in the D: drive on extraction. The folder
structure of a TAFJ area is shown in the slide.
DEV – contains files related to the current Dev stream
TAFJ folder – contains tafj runtime libraries and files. The path to this
folder is set as the TAFJ_HOME environment variable.
T24 folder – contains T24 data files and libraries. The path to this
folder is referred to as T24_HOME
IDE – EDS (enterprise design studio) software
3 party – contains 3rd party software's used in TAFJ – H2 database,
rd

jBoss and java development kit.

In the T24 folder, H2 database. Design Studio is used to write,

compile, debug and execute jBC code for T24. The eclipse TAFJ plugins enable this.
T24 data is stored in the H2 database. Double click on and start_H2.cmd to start the
H2 database. CMD opens a command prompt, where you may run tafj_Shell.cmd to
launch a TAFJ shell
i.e. it sets the environment to execute tafj commands like tShow, tDiag
etc.

TAFJ-R15
15
 Now that the base TAFJ area is ready you need to perform a upgrade . On TAFJ the
upgrade is a two step process.
1. Upgrade the TAFJ runtime libraries
2. Upgrade the T24 Data and libraries

This will be discussed in detail in a later session

TAFJ-R15
16
 Let us understand TAFJ_HOME in detail. This folder contains the TAFJ Runtime files
Appserver - Application server configuration files are kept here. These files are necessary for
deploying T24 on AS like jboss, Websphere, Weblogic, etc.
Bin - executable scripts (tRun, tCompile, ...).
CodeCoverage – contains cobertura jars for calculating and reporting test coverage. Primarily used
in regression tests
Conf - configuration directory where the project property files are maintained.
Data - Contains 2 folders - classes and java. Classes folder holds .class files generated and java
folder holds .java files generated, on compiling a jBC code.
Dbdrivers - drivers of the various databases supported in TAFJ can be found in this folder, for use
if needed.
Dbscripts – when you install a new database instance of say H2 or oracle, you need to run some
stored functions on the database to ready the new database for storing T24 data. These are
available as scripts in this folder, database wise.
Eclipse – contains the tafj plugins which enable jBC coding in Design Studio. These must be
linked/added to the plugins or dropins folder of Design Studio.
Ext - This is the folder to keep the external jars like [Link] for jboss, database drivers,
component framework jars etc.
JMSInjector – Contains JMSInjector to inject OFS into queues - for benchmark
Lib - TAFJ runtime libraries. Regression – contains scripts to perform regression testing.
Doc – TAFJ user guides. Log and log_T24 – end to end runtime logs and T24 logs for
splunk respectively

TAFJ-R15
17
Samples – sample basic codes TAFJSessionMonitor – contains TAFJ MW42 monitor.
RELEASE – contains code fix info [Link] – required for running maven builds

17
<TAFJ_HOME>/data/

/<Project Dir>/ - > The default project directory name. When you create a project in
Design Studio, the eclipse builder creates this directory automatically with the project
name. For eg DEV

/<Project Dir>/classes/ - >The final output of a compiled BASIC code goes here i.e.,
*.class eg <TAFJ_HOME>\data\DEV\classes

/<Project Dir>/java/ - >The temporary out of a compiled BASIC code goes here i.e.,
*.java. Eg <TAFJ_HOME>\data\DEV\java

18
TAFJ setup is based on a properties file. These files have a .properties file
extension. These are known as Property Resource. The property files contain
properties for configuring the behaviour of TAFJ projects and is available under
<tafj_home>\conf directory. Each property is stored as (key=value) pair of strings, one
storing the name of the property (called the key), and the other storing the value. For
eg [Link] = [Link]. All key=value pairs are loaded as Java
System Properties.
The following property files are available by default in the conf directory: .default,
.properties, [Link], [Link] along with [Link].
[Link] [Link] file is the default TAFJ configuration file. By default TAFJ
refers to this file for information on compiler, database, runtime etc. setting. It provides
vast information for the development and runtime environment on TAFJ.
[Link] may create multiple projects in Design Studio like DEV, R12, R14 etc. But only
one project is maintained as the default project. The property file name of the default
project is maintained in the file .default. In the TAFJ area shown in the snapshot,
[Link] is the default configuration file (instead of [Link]). This file
has only one entry. This file is useful when you execute tafj commands which expects
a property file name as a parameter, but has not been supplied. Tafj uses the default
property file in such cases.
If the filename in .default is incorrect and does not exist, then TAFJ will automatically
make [Link] as the default.

19
3.A property file can be defined manually. The default property file template is called
“.properties”. To manually create a different configuration, instead of overwriting the
default configuration file, copy the template and modify the property-values as required.
4. [Link] is a java policy file which define security permissions for the code to run.
[Link] configuration settings of the TAFJ logger(log4jlogger) is in the file
[Link]. TAFJ uses the standard LOG4J open source. TAFJ logs
information on compilation, runtime, database, execution etc. To change the log
levels(FATAL,ERROR, WARN,INFO, DEBUG) use this file. All log files go to
<TAFJ_HOME>\log
You can keep multiple T24 releases in one single setup of TAFJ. This is done using
property files. Property files can be manually created. Alternatively when you create a
TAFJ project in Design Studio, the project will have an associated property file with the
same name as the project. These configuration files have the extension “.properties”. In
the snapshot shown, there are three projects-DEV, R12 and R14, since there are three
property files by that name. Whenever a new project is created in Design Studio, the
Eclipse Builder TAFJ plug-in generates new configuration files using the project name.
The [Link] file can point to the Dev T24 area(say R15) on a H2 database
whereas [Link] file can point to an R14 T24 area on an Oracle database and
make the [Link] file reference an R12 area on MSSQL Server. This means that
when code is executed within the project called R14, the [Link] file is read and
the code is executed using the precompiled T24 jars of R14 and works with the Oracle
database, whereas in the R12 project, code will execute against an R12 T24 area and
store the data in an MSSQL database. Therefore in one TAFJ installation you can have
different T24 releases like R12, R14, Dev etc.

20
To check your tafj installation you can use the tDiag command. The command is
discussed in detail later.

It gives you information about your <TAFJ_HOME>, Runtime Version and many more.

Note that the default project is set as DEV. The .default file by default has the entry
[Link]. This has be overridden with [Link], that’s why the default
project is displayed as DEV.

21
 Navigate your TAFJ Dev area and

Launch Design Studio

Start your H2 database

TAFJ-R15
22
TAFJ-R15
23
A TAFJ standalone is nothing but just the TAFJ runtime and the precompiled jars of a
T24 release like R12 along with a backend database. You can run T24 classic in this
setup from a VT100 console.

24
 Use java –version at your command prompt to check the java version installed in your
machine. It should be 1.6 or above. If the version reported is not 1.6 (or above), you
should install it. Java JDK can be downloaded here:
[Link]
Set-up an environment variable called JAVA_HOME pointing to the root directory of
your java installation. Then, reference JAVA_HOME/bin in your PATH environment
variable.

TAFJ-R15
25
 After unzipping you will notice [Link] and [Link] and a jar file. To do a fresh
TAFJ installation from scratch and not starting from the dev image, then run the Setup.
This will create a folder (name it as TAFJ for convenience) with all the runtime related
files. This folder becomes your TAFJ_HOME.

[Note : For upgrading an existing TAFJ runtime, we make use of

“Patch_TAFJ.<version>.bat” on windows and “Patch_TAFJ.<version>.sh” for Unix. ]

TAFJ-R15
26
1. Set your JAVA_HOME to the location of your JDK
2. Run the [Link] file. Specify a location for your TAFJ_HOME. This creates
a folder called TAFJ by default. This folder contains all the runtime files and is
referred to as <TAFJ_HOME>
3. Copy the appropriate H2 database drivers from
<TAFJ_HOME>\dbdrivers\<database> to <TAFJ_HOME>\ext.
[Note: The H2 database version can be identified from the h2<Version>.jar in
<h2_home>\bin. For e.g. - [Link]]

27
[Link] your default property file in your new <TAFJ_HOME>\conf. You can identify
the default property file from the .default file. It should be [Link].
4. Note that the property [Link] is already set to your new <TAFJ_HOME> based
on the directory that you specified when running Setup.
[Link] the precompile path in the property [Link] to the location
of your T24 core libraries.
[Link] your database URL, driver, username and password properties to point to the
H2 database
[Note : The URL description and the specific driver information for each database is
mentioned under the Database Setup section. For H2 it is jdbc:[Link]://<host or
IP>:<port No>/<db_name>. The default H2 port is 9082. Since we are starting H2 at
port 9007, the same is mentioned. The database name is data. For the H2 database
that we are using the username is t24 and password is t24]

28
7. Start your H2 database at port 9007. The sql> prompt suggests that the database
has started.

29
8. Navigate to <TAFJ_HOME>\bin from your windows command prompt and execute
tDiag.

Note that the default project is set as tafj. This is because, the .default file has the
entry [Link]. This entry can be overridden and any other project can be made
as the default.

30
9. From a vt100 console execute the command tRun EX to launch T24 Classic.

[Note: Execute tRun from <tafj_home>\bin]

31
10. Setup TAFJ Plug-ins in Design Studio
Once the setup of TAFJ is completed and if you have EDS installed, create a folder
called dropins in <DesignStudio-Home>. The TAFJ plugins are available in the
<TAFJ_HOME>/eclipse/plugins folder. You can simply link the contents of this
directory to the directory <DesignStudo-Home>/dropins. The TAFJ plugins are
necessary for using EDS as the IDE for T24 development.
1. [Link] a file <name>.link for e.g., [Link] in <DS-Home>/dropins.
[Link] the file [Link] and add a property key called path=relative path from <DS-
Home> to <TAFJ_HOME>
i.e.
For the directory structure:
+---IDE
| +---DesignStudio <DS-Home>
| | +---dropins
+---TAFJ

path=../../TAFJ

32
Launch EDS by clicking on [Link] in the DesignStudio folder
2. Verify that all TAFJ Plug-ins are loaded with EDS.
Help -> About Design Studio for T24 ->Installation Details ->Tab: “Plug-ins”. You must
find the tafj plugins shown in the snapshot.

Plugin Versioning follows this pattern.

<Release Version>.<Service Pack>.<MonthlyBuild-1>
For eg Version 14.3.0 is R14.SP3 and 15.0.2 is the current dev, march build.
Remember it is Monthlybuild - 1

3. You should also be able to load the TAFJ Perspective.

33
34
35
When you execute a tafj command, a check is made to see if you have used the –cf option with
the command. If the configuration file exists, then the properties settings of the configuration file
specified are used for execution else an error is displayed. If –cf option is not used, then a check
is made to see if the .default file exists. If yes, read .default entry. If the configuration file specified
in .default exists then use that file, else use [Link] which is the default. If [Link] is
not available, then display error.

36
The file .default in the <TAFJ_HOME>/conf directory can be used to set a default
configuration. By default the value in the text file: .default is set to [Link].
The default property file template is called “.properties”. To manually create your
property file, copy .properties into a file called T24_Dev.properties as shown. Then
edit T24_Dev.properties.
1. Set your T24 core libraries path and the database properties as you did in the
previous session.
2. Specify a path where you would store your basic routines in the property
[Link]. You can specify multiple directories separated by a :
or ;
3. By convention, the java and class path for TAFJ of a project have to be set
under:
<TAFJ_HOME>\data\<ProjectName>\java and classes. The related properties
are [Link] and [Link]. For e.g.,
<[Link]>\data\T24_Dev\java
4. Edit your .default to now refer to T24_Dev.properties.
[Note: In your TAFJ development area, the .default is set to [Link] instead of
[Link] because the DEV project in Design Studio has been made the default
project]

37
[Link] - points to the TAFJ folder in your tafj area which contains the runtime
libraries and other related files.
[Link], folder location to all your basic source files. You can
specify multiple paths with the separators “:” or “;”.
[Link], folder location where the INSERT files for your project is
kept. The Insert file can be in the basic source folder itself or in a different path.
[Link], folder location where the java source files should be
generated. This property is mandatory and you can set only one path.
[Link], folder location where the classes files should be
generated. This property is mandatory and you can set only one path.
[Link], refers to the folder location where the precompiled
class files are kept. Usually contains the precompiled t24 class files required by your
t24 basic code. Multiple paths can be specified using the separators. The precompile
paths are overridden by ”[Link]” paths. For e.g. you have a
class [Link] in the precompile path. You compile a [Link] which inturn calls
[Link]. In this case the [Link] in the precompiled path will be called. Now if
you generate a new [Link] in classes path, then [Link] will not call the
[Link] in the precompile path. Instead it calls the one in the classes path. This
path could be a folder or JAR file.
[Note : The preferred location for T24 precompiled is <t24_home>/lib in your Dev
area]

38
TAFJ-R15
39