Download HPE NonStop Server for Java Standard Edition 7.0 software: An

Data sheet
HPE NonStop Server for
Java Standard Edition 7.0
software
An enterprise-class environment for server-side
Java applications
This enterprise-class software environment enables
development of Java applications that take advantage of
the mission-critical features of HPE NonStop Servers.
HPE recommends Java.
Reduce execution pause
HPE NonStop Server for Java Standard
edition 7.0 software supports much larger
amounts of heap memory than previous
versions of NSJ by virtue of its capability
to operate in 64-bit mode. It implements
new garbage collection algorithms that
reduce the “stop-the-world” application
execution pause intervals by a significant
factor compared to earlier versions.
Meet all the demands of
enterprise applications
Developers must consider multiple demands
when creating business-critical enterprise
applications. Unfortunately, the demands
for availability, scalability, and data integrity
often mean that attention to design and
functionality are compromised in order to
meet short development windows. A platform
automatically providing these critical features
will help streamline development workflows
and free-up time that can be devoted to the
functional aspects of application development.
HPE NonStop Server for Java Standard
Edition 7.0 (HPE NSJ 7) software is
an enterprise-class software platform
that supports 64-bit applications, PUT
library, and faster garbage collection (GC)
algorithms. Together with HPE NonStop
Servlets for JavaServer Pages, HPE JToolkit
for HPE NonStop Servers, Java Database
Connectivity (JDBC) drivers for HPE NonStop
SQL, HPE NonStop Application Server for Java,
and HPE NonStop Message Queue software,
this solution provides all the advantages of the
Write-Once-Run-Anywhere of Java, enabling
1
Headless mode is a system configuration in which
the display device, keyboard, or mouse is lacking.
For further information refer to: oracle.com/
technetwork/articles/javase/index-140348.html
development of Java applications that take
advantage of the mission-critical features of
HPE NonStop Servers.
This enables application developers to
concentrate on their business workflow while
the availability, scalability, and data integrity
needs are taken care of by HPE NonStop
Servers.
This data sheet describes the various features
offered in HPE NonStop Server for Java
Standard Edition 7 Update 2 (NSJ 7 U2) and
the accompanying JToolkit software. Two new
features that have been released in NSJ 7 U2
are thread pre-emption capability and a beta
version of G1 GC algorithm.
Compatible with Java SE 7.0 specification
The solution is a certified implementation of
the Java SE 7.0 and implements all application
programming interfaces (APIs) and tools
that are defined for a headless1 configuration
of Java SE 7.0. To view a complete list
of features in Java SE 7.0 refer to oracle.
com/technetwork/java/javase/jdk7relnotes-418459.html.
Data sheet
Page 2
64-bit Java virtual machine (64-bit JVM)
HPE NSJ 7 uses the 64-bit addressing
capability of the HPE NonStop Kernel to
provide applications with large native heap
and flat segments. Applications utilizing
HPE NSJ 7 can use much larger Java heap
space than in previous versions of NSJ. Up
to NSJ 6 applications were provided with a
maximum heap memory of about 1.3 GB.
With 64-bit addressing capability in HPE NSJ
7, applications can use hundreds of GB of
heap memory. The maximum heap size is
only limited by that which is provisioned in the
system.
However, it is always advisable for applications
to use just the required heap size so that
garbage collection pauses can be minimized.
To assist optimum memory allocation for
applications, from NSJ 7 U1 release onwards,
two CLI options are provided for controlling
the JVM heap size. It is to be noted that the
64-bit addressability is applicable only for
heap and flat segments; the code segment and
static data will remain in the 32-bit address
space. More details can be found in the
technical white paper “Heap Management in
HPE NonStop Server for Java 7.”
You may also like to read the white paper
“Monitoring HPE Integrity NonStop
Servers for Java memory.”
Note
If the total heap size (Java heap + native
heap + flat segments) of an application
is more than the physically configured
memory, then “memory thrashing” issues
may occur.
New garbage collection algorithms
Larger memory capacity offered by the 64-bit
HPE NSJ 7 needs faster garbage collection
in order to prevent adverse impact on user
applications. HPE NSJ 7 provides two new
garbage collection algorithms, namely parallel
GC and Concurrent Mark Sweep GC (CMS
GC). These two GC algorithms are available
on HPE Integrity HPE NonStop BladeSystem
servers, i.e., the command-line options
pertaining to the new GC algorithms are
enabled only if the HPE NSJ 7 is running on
HPE BladeSystem servers. The parallel and
CMS GC threads will run as independent
processes in their own right—separate from
the parent Java process—but they share its
memory space. The number of GC processes
created depends upon the number of cores
in the processors. Several configurable
parameters are provided in order for the user
to control the behavior of the GC algorithms.
More information on these two garbage
collection algorithms can be found in the
technical white paper “Garbage collection in
HPE NonStop Server for Java 7.”
From NSJ 7 U2 release onwards NonStop
Server for Java 7 platform also provides
support for Garbage First GC (aka G1 GC)
algorithm. In NSJ 7 U2 this algorithm is made
available as beta version. It will be certified for
full production use in a future update of NSJ 7.
Pthreads library
HPE NSJ 7 uses the new Pthreads library,
namely ZPUTDLL (32-bit version) and
YPUTDLL (64-bit version). They provide
non-blocking I/O for all files, protected stack,
and alternative signal stack. This library is
more compliant with POSIX than the SPT
library (ZSPTDLL) used by earlier versions
of HPE NSJ. Java Native Interface (JNI)
applications that use the invocation API
must link with either ZPUTDLL or YPUTDLL.
Similarly, user-written multi-threaded JNI
applications need to use the PUT version of
thread library functions.
Note
Dynamic loading of the Pthreads library is not
possible. An application needs to be started
as a threaded application—unlike in the case
of the SPT application by dynamically loading
ZSPTDLL.
Data sheet
Page 3
Thread pre-emption capability
From NSJ 7 U2 onwards application writers
can optimize the performance of their
multi-threaded applications by configuring a
timer which will guard how long a particular
thread will be able to use the services of a
CPU. When the timer expires a SIGTIMEOUT
is delivered by the Kernel. The signal handler
will then make the currently running thread
“yield” the CPU to another thread that is at
the top of the waiting list. The thread that had
just yielded will be then placed at the end of
the list.
feature is intended to help developers—who
are knowledgeable in Java but are unfamiliar
with HPE NonStop TS/MP s/w and its APIs—to
develop Java applications and readily deploy
them as server classes. JI provides a Java
abstraction to HPE NonStop File System (FS)
and TS/MP APIs. It enables programmers to
use Socket class in the java.net package or
the SocketChannel in the java.nio package
to write HPE NonStop TS/MP or standalone
server-class applications without having
to use any FS or Pathsend API. With this, a
programmer can use plain sockets or any
package that uses sockets for communication
to write server applications and host them
on HPE NonStop TS/MP and inherit the
unique features of HPE NonStop TS/MP. Such
programs can be developed and tested on a
desktop environment and seamlessly deployed
on HPE NonStop as TS/MP server classes. JI
is shipped by default in all SUTs. From NSJ 7
U2 release onwards JI is shipped as a software
module of its own.
This feature ensures that no application/thread
can monopolize the CPU time for oneself and
that all threads will get an even chance to run.
The system user or application writer can
configure the value for this timer appropriately
as per their deployment needs. A new
configuration parameter is made available to
control the timer value.
NSJ Infrastructure
HPE NSJ 7 brings in a new facility called
NSJ Infrastructure (JI). The HPE NonStop
platform’s unique ability to provide applications
with continuous availability and near-linear
scalability relies on its Transaction Services/
Massively Parallel (TS/MP) software. The JI
Without JI
Figure 1 shows how JI is used to abstract
the FS and TS/MP APIs. More details are
available in HPE NonStop Server for Java
7.0 Programmer’s Reference which may be
downloaded from hp.com/go/nonstop-docs.
With JI
Client application
Client application
Application
Application
Java.net.socket/
java.nio.SocketChannel
Java.net.socket/
java.nio.SocketChannel
TCP/IP
JI
Pathsend/FS API
TCP/IP
JI
Java.net.socket/
java.nio.SocketChannel
Java.net.socket/
java.nio.SocketChannel
Application
Application
Server application
Server class
Figure 1: How JI is used to abstract the FS and TS/MP APIs
Data sheet
Supported by a broad range of
development tools
Applications designed to run in the
HPE NonStop Server for Java environment
can be built using many popular Java
development tools. For example, you
can take advantage of the HPE NonStop
Development Environment for Eclipse. In
addition a wide selection of commercial
and open source development tools are
available on Microsoft® Windows® and
Linux® OS.
Page 4
Apart from the above features, existing
tools/utilities such as NSJPS, HPjmeter, and
Vproc have also been enhanced to provide
details about both 32-bit and 64-bit JVM.
In addition, JToolkit for HPE NonStop Servers
software (bundled with HPE NonStop Server
for Java 7.0) provides APIs and tools that
combine the advantages of Java technology
with your knowledge of existing HPE NonStop
Server products, such as HPE NonStop
Pathway and Enscribe software. These Java
APIs allow you to take advantage of the
productivity features of the Java language
to design new applications that provide deep
integration with existing software assets and
leverage existing knowledge and skill sets.
Compatible with Java
technology
HPE NonStop Server for Java software is
a compatible version of Java SE 7.0 Java
Development Kit (JDK 7). It includes the
following standard Java components:
•All core Java APIs of JDK 7
Easy integration with
HPE NonStop SQL databases
•JDK 7 tools, except tools that require a GUI
for functionality
HPE NonStop Server for Java software
includes JBDC driver software needed to
access HPE NonStop SQL database tables.
HPE NonStop Server for Java software can
access HPE NonStop SQL relational database
management software through the standard
JDBC 4.0 API.
Compatibility with versions
earlier than HPE NSJ 7
HPE NonStop Server for Java software
also supports a transaction package that
Type of application
provides access to HPE NonStop Transaction
Management Facility (HPE NonStop TMF)
software. The package can be used with
the transaction-aware HPE NonStop SQL
database drivers to define transactions across
services, such as those that include both
JDBC and Java-to-Pathway calls.
HPE NSJ 7 is compatible with earlier JDK
versions and so a pure Java application
developed for pre-HPE NSJ 7 JDK can be run
on HPE NSJ 7 JDK without any modification to
the application. For other types of applications,
there may be some changes needed. The
following table gives more details.
Porting changes for HPE NSJ 7
32-bit JDK
64-bit JDK
Pure Java application
No change
No change
Non-threaded native library
Recompilation may be needed
Recompile as 64-bit application
Threaded native library
Recompile by specifying _PUT_MODEL and link with
ZPUTDLL
Recompile as 64-bit application by specifying _PUT_
MODEL and link with YPUTDLL
Non-threaded JNI invocation application
Recompile and link with ZPUTDLL
Recompile as 64-bit application and link with YPUTDLL
Threaded JNI invocation application
Recompile by specifying _PUT_MODEL and link with
ZPUTDLL
Recompile as 64-bit application by specifying _PUT_
MODEL and link with YPUTDLL
Data sheet
Page 5
HPE JToolkit 2.0
for HPE NonStop
Servers software
HPE JToolkit for HPE NonStop Servers
software, bundled with HPE NonStop Server
for Java 7.0, provides you with APIs and
tools that combine the advantages of Java
technology with your knowledge of existing
HPE NonStop Server products, such as
Pathway and Enscribe software. Programmers
can take advantage of the productivity
features of the Java language to design new
applications that provide deep integration with
existing software. JToolkit for HPE NonStop
Servers includes the following software:
Java API for Pathway
This allows you to write fully-functional
Pathway server applications using the Java
language. The APIs provide support for writing
both single-threaded and multi-threaded
Pathway servers.
Java API for Enscribe
This provides you with a simplified API
for accessing Enscribe files from Java
applications.
Java API for Pathsend
This enables Java applications running
on HPE NonStop Servers to send request
messages to and receive replies from existing
Pathway servers.
ddl2java
A command-line tool that generates Java
classes from data descriptions defined in a
data definition language (DDL) dictionary
file. The Java classes implement methods
to convert Java data types to HPE NonStop
OS data types, and vice versa. These classes
can then be used with Java APIs for Pathway,
Enscribe, and Pathsend to further simplify the
development of your business logic.
Scalable TCP/IP (SIP) software
This provides a transparent way to give
the HPE NonStop Server advantages of
scalability and availability to a network server
(SIP server) written in Java. Because SIP does
not introduce any APIs, existing network
servers written in Java and their clients can
take advantage of SIP without substantial
changes in code.
These APIs and tools are fully integrated
with the JVM’s threading engine. This
allows you to write efficient multi-threaded
Java applications by leveraging Java’s
native threading facilities. Specifically, all
I/O operations such as reading $RECEIVE,
reading, or writing Enscribe records, and
performing Pathsends are synchronous with
respect to a given Java thread. This means
that while a thread is blocked and waiting
for the I/O operation to complete, all other
threads within the application can be running.
Off platform availability of JToolkit
methods
Starting with NonStop Server for Java
7 Update 1 (NSJ 7 U1) release the pure
Java methods of JToolkit are available and
usable off platform. For example, a Pathway
server or ddl2java generated I/O class can
directly call the data conversion methods
from within a non-NonStop platform such as
Windows, UNIX®, Linux, and Solaris.
Data sheet
Page 6
Java API for Pathway
Pathway
Server
Class
Supports both context-free
and dialog modes of $RECEIVE
messages
The Java API for Pathway product
enables you to perform the following
functions:
• Open and close $RECEIVE
• Perform a read operation on
$RECEIVE
• Reply to a message read from
$RECEIVE
• Perform multiple reads on $RECEIVE
before replying
• Cancel an outstanding read on
$RECEIVE
• Reply to messages in any order
• Set priority or first-in, first-out ordering
of messages in the $RECEIVE queue
• Enable receipt of user-selected system
messages
• Enable an optional notification,
through a Java exception, when there
are no more openers
Java API for Pathway comprises the
following four major classes:
•Receive—This class represents the
$RECEIVE variable. The class provides
methods to open and close $RECEIVE,
read and reply to $RECEIVE messages,
and cancel an outstanding read. In addition,
various set methods are provided to set
$RECEIVE attributes such as receive depth
and sync depth.
•ReceiveInfo—This class provides information
about the last read request message and
provides various get methods that return
information about the attributes associated
with the message.
•ReceiveNoOpeners—This is an exception
class, an instance of which is called if a read
is performed on $RECEIVE when there are
no more openers. You have the option of
disabling this exception class.
•ProcessHandle—This class provides
methods to decompose a HPE NonStop
OS process into its constituent parts. The
methods provided in this class can be used
to find detailed information on the process
that sent the request.
You can use the methods associated with
these classes to write both single-threaded and
multi-threaded Pathway server programs.
Basic structure of a
single-threaded
server program
The simplest form of a Pathway server is a
single-threaded server that processes one
request at a time. Such servers can generally
be written in the following sequence:
•Obtain an instance of the $RECEIVE class
using Receive.getInstance()
•Set any $RECEIVE attributes for which
the supplied default does not fit your
needs; some attributes, such as receive
depth and sync depth, must be set before
opening $RECEIVE, while other attributes
can be set after opening $RECEIVE
•Open $RECEIVE using Receive.open()
•Read a message from $RECEIVE using
Receive.read()
•Perform whatever business logic is
outlined in the message
•Reply to the message using Receive.reply()
Continue reading and replying to messages
until no more openers of the server exist, which
can be signaled when a ReceiveNoOpeners
exception is called.
Considerations for
multi-threaded server
programs
Multi-threaded servers have the ability
to process multiple request messages
concurrently. Because these APIs are
thread-aware, you can leverage Java’s native
threading facilities to significantly simplify
your multi-threaded server programs.
A multi-threaded server can use two different
models to read and process requests. The first
model has one thread performing all the read
operations on $RECEIVE and handing off the
requests to other threads for processing. The
second model has multiple threads performing
read operations, each of which is responsible
for processing the request that it reads.
In summary, Java API for Pathway allows you
to leverage the power of the Java language
to write fully-functional Pathway server
programs.
Data sheet
Page 7
JEnscribe
Enscribe
The Java API for Enscribe enables you
to perform the following functions:
• Create a new file
• Open an existing file
• Alter the characteristics of an existing
file
• Rename an existing file
• Purge an existing file
• Read a file sequentially
• Position to a particular record within
a file
• Lock a file or a record within a file
• Unlock a file or a record within a file
• Write records to a file
• Obtain information about an existing
file
• Close a file
Java API for Enscribe
––KeySequencedCreationAttributes—For
key-sequenced files
Java API for Enscribe (JEnscribe) provides
wrapper classes for Enscribe procedure calls
that give Java programs access to Enscribe
disk files. These wrapper classes make it easy
for Java developers to access and use Enscribe.
––UnstructuredCreationAttributes—For
unstructured files; exists to set and get
file-creation attributes for a particular file
type
Java API for Enscribe provides access to the
following types of Enscribe files: key-sequenced,
relative, entry-sequenced, and unstructured.
Also, the APIs support both format 1 and
format 2 files. (Format 2 files support a larger
file and partition size.)
The following is an overview of the eight
major classes that Java API for Enscribe is
comprised of:
•EnscribeFile—This class provides
methods that allow you to perform
standard operations on Enscribe files.
•EnscribeOpenOptions—This class provides
methods to set the various options
needed to open a file. An instance of this
class is set with the required options and
passed as a parameter to the EnscribeFile.
open() method. The open method of the
EnscribeFile class is also overloaded to open
a file by specifying only the access and
exclusion mode.
•EnscribeFileAttributes—This class provides
GET methods to obtain information about
the attributes of an existing file and set
methods that can be used to alter the
attributes of an existing file.
•EnscribeCreationAttributes—This class
is an abstract class with subclasses that
provide methods to set and get file-creation
attributes. Subclasses such as:
––StructuredCreationAttributes—For
relative-and entry-sequenced files
•EnscribeLastCallStatus—This class provides
methods to retrieve transient attributes of a
file after performing an operation on the file.
•AlternateKeyDescriptor—This class provides
GET methods to obtain the attributes of a
specific, alternate key and also provides SET
methods to change those attributes.
•EnscribeKeyPositionOptions—This class
provides SET and GET methods to position
within a file according to the value of the
primary or alternate key.
•PartitionDescriptor—This class provides
GET methods to obtain the attributes of a
specific partition and also SET methods to
change those attributes.
For operations on audited files, you must
use either the Java Transaction API or other
methods provided by com.tandem.tmf classes
to perform transaction management.
In summary, Java API for Enscribe provides a
simple API that hides the complexity behind
the raw Enscribe procedure calls. In addition,
because these APIs are thread-aware, you can
write multi-threaded programs by leveraging
Java’s native threading facilities. All I/O
operations are synchronous with respect to
a given Java thread. However, while a thread
is blocked waiting for the I/O operation
to complete, all other threads within the
application can still be running.
Data sheet
Page 8
JPathsend
Supports JPathsend messages less than
2 MB
Pathway
Server
Class
The Java API for Pathsend provides the
following functionality:
• Marshals a Java object representing
a request to a Pathway server class
so that the instance variables of the
object are converted to HPE NonStop
OS data types, which are then placed
in the Pathsend buffer as a request
message
• Unmarshals a response Pathsend buffer
so that the HPE NonStop OS data
types can be converted to the instance
variables of a Java object representing
the response from a Pathway server class
• Performs a Pathsend request to a
Pathway server class
Java API for Pathsend
•Use the various GET methods of the
response object to retrieve the reply data.
Java API for Pathsend (JPathsend) allows
a Java application to send requests to and
receive replies from Pathway servers without
requiring any modifications to the server.
For example, the Java application could be a
Java servlet that, in essence, provides a Web
interface to the Pathway server.
In summary, Java API for Pathsend provides
an easy mechanism for Java applications
to invoke Pathway services. When used
with the ddl2java, you do not have to worry
about data conversions between Java data
types and HPE NonStop OS data types.
The TsmpServer and TsmpServerWide classes
are the major classes of Java API for Pathsend
(to send up to 32 KB or 2 MB sized Pathsend
requests respectively). These classes are used
to communicate with the Pathway server. In
the constructor of these classes, you provide
the name of the target server class, as well as
the Pathmon under which the target server
class runs. The classes also provide several
overloaded service methods that are used to
perform the actual Pathsend.
Usage scenario
To use the Java API for Pathsend, you will
typically use the following sequence:
•Use the ddl2java tool (described later)
to generate Java classes representing the
request and reply data structures defined in
a DDL dictionary file.
•Use the various SET methods of the
generated request class to set the request
data.
•Instantiate an object of type TsmpServer
or TsmpServerWide.
•Use the service method to send the request
and receive a response. This method can
automatically marshal the request object
before sending the request and unmarshal
the response to the response object.
ddl2java
The ddl2java tool is a command-line tool
that can generate Java classes from data
descriptions, such as data definitions or data
records defined in a DDL dictionary file.
These classes can then be used to:
•Read and reply to messages read from
$RECEIVE using Java API for Pathway
•Read or write data to an Enscribe file using
Java API for Enscribe
•Send or receive data from a Pathway
server using Java API for Pathsend
Using ddl2java simplifies the development
required to use Java API for Enscribe and
Java API for Pathsend. For example, if you
were to deal with a byte array for performing
Pathsends, you would have to write code to
marshal your request object (that is, convert
Java data types to HPE NonStop OS data
types expected by the Pathway server)
and unmarshal the reply to a response
object (that is, convert the server reply from
HPE NonStop OS data types to Java data
types). Using ddl2java simplifies your code
because it can generate classes that can do
the marshalling and unmarshalling for you.
Data sheet
Page 9
Depending on the options passed to the
ddl2java tool, the tool generates classes
that implement one or both of the following
interfaces: GuardianOutput and GuardianInput.
Objects of type GuardianOutput can be used
to reply to messages read from $RECEIVE,
write records to Enscribe files, and send
requests to Pathway servers. Objects of
type GuardianInput can be used to read
messages from $RECEIVE, read records
from Enscribe files, and receive replies from
Pathway servers. Classes that implement
the GuardianOutput interface are known
as output classes, classes that implement the
GuardianInput interface are known as
input classes, and classes that implement both
interfaces are known as I/O classes.
Instances of output classes are used as
parameters to certain methods. For example,
the object representing the request in the
service method of the TsmpServer class
can be an output object. Similarly, instances
of input classes are used as in parameters
to certain methods. For example, the various
read methods of the EnscribeFile class accept
an input object as a parameter. Instances of I/O
classes can be used wherever an output object
or an input object is acceptable.
For each class that ddl2java generates from
a DDL data description, the following are
also generated:
•Java class names—ddl2java forms the
generated class name by shifting up the first
character of the DDL description name and
adding the prefix O for output classes, the
prefix “I” for input classes, and the prefix “IO”
for I/O classes.
•Instance variable names—ddl2java maps
DDL field names to Java instance variable
names with no changes, except in cases
where the name conflicts with Java syntax
rules (for example, replacing a hyphen with
an underscore).
•Instance variable data types—The data types
of instance variables are similar to the DDL
data types. For example, the DDL binary-16
data type is mapped to the Java data type
short, while the float-64 data type is mapped
to the double Java data type.
•SET and CLEAR methods—ddl2java
generates SET and CLEAR methods for
output and I/O classes. ddl2java creates
a SET method name from a variable name
by shifting up the first letter of the Java
instance variable name and adding the
prefix set. ddl2java also generates CLEAR
methods that can be used to clear values
previously set. CLEAR methods set instance
variables—that are declared as—short,
int, long, float, or double to zero and set
instance variables that are declared as
string to null.
•GET methods—The ddl2java tool generates
get methods for input and I/O classes. The
tool creates a GET method name from a Java
instance variable name by shifting up the first
letter of the Java instance variable name and
adding the prefix GET.
•Calls to conversion methods—ddl2java
generates calls to conversion methods that
convert and move the data to and from
HPE NonStop OS data types.
Data sheet
Customize your IT lifecycle
management, from acquisition of new
IT, management of existing assets,
and removal of unneeded equipment.
hp.com/go/hpfinancialservices
Page 10
––Marshal—For output and I/O classes,
ddl2java generates a marshal method
that converts the values of the instance
variables to HPE NonStop OS data types
and places these values in a byte array.
This method is typically called before
writing data out. Methods in the Java
APIs for Pathway, Enscribe, and Pathsend
that accept an output (or I/O) object
automatically call this method for you.
––Unmarshal—For input and I/O classes,
ddl2java generates an unmarshal method
that takes HPE NonStop OS data in a byte
array, converts it into Java data types, and
moves it to individual fields in the input
or I/O object. This method is typically
called after reading data in. Methods in
the Java APIs for Pathway, Enscribe, and
Pathsend that accept an input or I/O object
automatically call this method for you.
In summary, ddl2java further simplifies the
development effort required to use the APIs
for Pathway, Enscribe, and Pathsend software
by generating classes that can marshal and
unmarshal the data, as well as providing
SET and GET methods to set and retrieve
instance variables.
SIP software
SIP software provides a transparent
way to provide the system advantages of
HPE NonStop Servers, such as scalability and
availability, to a network server (SIP server)
written in the Java language. Existing servers
written in Java and their clients can take
advantage of SIP with no code changes.
SIP provides a method for distributing
client requests among SIP servers. The
distributor and SIP servers run as Pathway
server classes. Running under the Pathway
environment gives SIP the manageability,
load balancing, and scalability benefits of
HPE NonStop Servers.
More details can be found in the “JToolkit for
HPE NonStop Server for Java Programmer’s
Reference and API” document. The “JToolkit
for Java API Reference” pages describe how
to access it.
SIP tools
The following SIP tools are provided:
•Configuration—Configures a new SIP
application
•Reconfiguration—Reconfigures an existing
SIP application
•Management—Manages and views the
attributes of an existing sip application
Technical specifications
System requirements
Hardware
HPE Integrity NonStop BladeSystem servers
HPE Integrity NonStop X servers
Software
HPE NonStop OS, RVU J06.15, or later (for HPE Integrity NonStop BladeSystem)
HPE NonStop OS, RVU L15.02, or later (for HPE Integrity NonStop X servers)2
Note
HPE JToolkit 2.0 for HPE NonStop Servers software is included with HPE NonStop Server for
Java 7.0
2
he RVU version L15.02 carries the NSJ 7 U1
T
software. The NSJ 7 U2 software will be included
in the next HPE Integrity NonStop X OS RVU.
Data sheet
Page 11
HPE Factory Express
HPE Factory Express provides customization
and deployment services along with
your storage and server purchases. You
can customize hardware to your exact
specifications in the factory—helping speed
deployment. hp.com/go/factoryexpress
Customer Technical Training
Unleash the potential of your HPE NonStop
system with in-depth training from
HPE Education Services. With HPE NonStop
training you will accelerate your
technology transition, improve operational
performance, and get the best return on your
HPE investment. Our training is available
when and where you need it, through
flexible delivery options and a global training
capability. hp.com/learn/nonstop
HPE Technology Services help build an
infrastructure that is reliable, highly available
and rooted in best practices. hp.com/
services/nonstop
Learn more at
hp.com/go/nonstop
Data sheet
Sign up for updates
© Copyright 2014–2016 Hewlett Packard Enterprise Development LP. The information contained herein is subject to change
without notice. The only warranties for Hewlett Packard Enterprise products and services are set forth in the express warranty
statements accompanying such products and services. Nothing herein should be construed as constituting an additional warranty.
Hewlett Packard Enterprise shall not be liable for technical or editorial errors or omissions contained herein.
Java and Java Compatible logo are registered trademarks of Oracle and/or its affiliates. Microsoft and Windows are trademarks of
the Microsoft Group of companies. UNIX is a registered trademark of The Open Group. Linux is the registered trademark of Linus
Torvalds in the U.S. and other countries.
4AA5-0726ENN, October 2016, Rev. 2