SAP Adaptive Server Enterprise 16.0
SAP Adaptive Server Enterprise 16.0 (Japanese)
SAP Adaptive Server Enterprise 16.0 (Simplified Chinese)
Adaptive Server Enterprise 15.7 SP121
Adaptive Server Enterprise 15.7 SP110
Adaptive Server Enterprise 15.7 SP100
Adaptive Server Enterprise 15.7 SP60
Adaptive Server Enterprise 15.7 SP50
Adaptive Server Enterprise 15.7 ESD #4
Adaptive Server Enterprise 15.7 ESD #3
Adaptive Server Enterprise 15.7 ESD #2
Adaptive Server Enterprise 15.7 ESD #2 (Japanese)
Adaptive Server Enterprise 15.7 ESD #2 (Simplified Chinese)
Adaptive Server Enterprise 15.7
Adaptive Server Enterprise 15.7 (Japanese)
Adaptive Server Enterprise 15.7 (Simplified Chinese)
Adaptive Server Enterprise 15.5
Adaptive Server Enterprise 15.5 - Simplified Chinese
Adaptive Server Enterprise 15.5 (Japanese)
Adaptive Server Enterprise 12.5.4
Adaptive Server Enterprise 12.5.4 (Simplified Chinese)
Adaptive Server Enterprise 12.5.4 (French)
Adaptive Server Enterprise 12.5.4 (Japanese)
Adaptive Server Enterprise 12.5.3
Adaptive Server Enterprise 12.5.2
Adaptive Server Enterprise 12.5.1
AppBuilder 1.0
Appeon 6.5.1 for PowerBuilder
Appeon 6.5 for PowerBuilder
Appeon 6.2 for PowerBuilder
Appeon 6.1 for PowerBuilder
Appeon 6.0 for PowerBuilder
Appeon 6.0 for PowerBuilder (Japanese)
Avaki EII 7.1
Avaki EII 7.0
Avaki EII 6.2
DataWindow .NET 2.5
DataWindow .NET 2.0.1
DataWindow .NET 2.0
EAServer 6.3.1
EAServer 6.3
EAServer 6.2
EAServer 6.1
EAServer 6.0.2
EAServer 6.0
EAServer 5.5
EAServer 5.3
Release Bulletin EAServer 5.3 for Sun Solaris
Accessing current release bulletin information
Product summary
System requirements
Required system patches
Upgrading JDK 1.3 for Daylight Saving Time
Special installation instructions
Changed functionality in this version
Known problems
EAServer Manager issues
Apply buttons
Start ASA9 before testing connection caches
No core dump generated
EAServer security libraries
Possible security vulnerability with Sybase Central and Sybase Central plug-ins running on Sun Solaris
Security Administration issues
Online help Key/Cert wizard
Base64 encoded X.509 certificate not compatible
EAServer SSL client runtime
Web Services Toolkit issues
Expired VeriSign root certificate
Exposing components as Web services
Incorrect datatype in WSDL by Axis 1.2
Readme and sample updates
Other issues
Possible security vulnerability using password fields in J2EE or Java GUI applications on Sun Solaris
Eclipse runs out of memory when handling large return values
Fixed problems
Product compatibilities
PowerBuilder
Code set interoperability
Borland JBuilder
PowerDynamo
Application Integrator
Earlier EAServer (Jaguar CTS) versions
Documentation updates and clarifications
EAServer Troubleshooting Guide
Chapter 6, Advanced Topics
EAServer System Administration Guide
Chapter 4, Database Access
Chapter 8, Setting up the Message Service
Appendix B, Repository Properties Reference
EAServer Programmer’s Guide
Chapter 2, Understanding Transactions and Component Lifecycles
Chapter 23, Using Filters and Event Listeners
EAServer Performance and Tuning Guide
Chapter 4, EJB CMP Tuning
EAServer Feature Guide
Chapter 1: Introducing EAServer
EAServer Cookbook
Chapter 4: Creating Enterprise JavaBeans Components and Clients
EAServer API Reference Manual
Chapter 5, C Routines Reference
Technical support
Other sources of information
Sybase certifications on the Web
Sybase EBFs and software maintenance
Accessibility features
Release Bulletin EAServer 5.3 for Windows
Accessing current release bulletin information
Product summary
System requirements
Required system patches
Upgrading JDK 1.3 for Daylight Saving Time
Special installation instructions
Silent installation and Eclipse
Installer problems with display control interface support
Changed functionality in this version
Known problems
Web server redirector plug-in
IIS 6.0 Web server redirector plug-in
iPlanet 6 Web server redirector plug-ins
IPV6 not yet supported
EAServer Manager
Systems Management
Security Administration
Online help Key/Cert wizard
Base64 encoded X.509 certificate not compatible
Web Services Toolkit issues
Expired VeriSign root certificate
UDDI search and registration
Exposing components as Web services
Incorrect datatype in WSDL by AXIS 1.2
Readme and sample updates
Other issue
Fixed problems
Product compatibilities
PowerBuilder
Known issues
Code set interoperability
Borland JBuilder
PowerDynamo
Application Integrator
Earlier EAServer (Jaguar CTS) versions
Documentation updates and clarifications
EAServer Troubleshooting Guide
Chapter 6, Advanced Topics
EAServer System Administration Guide
Chapter 4, Database Access
Chapter 8, Setting up the Message Service
Appendix B, Repository Properties Reference
EAServer Programmer’s Guide
Chapter 2, Understanding Transactions and Component Lifecycles
Chapter 23, Using Filters and Event Listeners
EAServer Performance and Tuning Guide
Chapter 4, EJB CMP Tunning
EAServer Installation Guide
Chapter 4, Installing and Configuring a Web Server Redirector Plug-In
EAServer Feature Guide
Chapter 1: Introducing EAServer
EAServer Cookbook
Chapter 4: Creating Enterprise JavaBeans Components and Clients
EAServer API Reference Manual
Chapter 5, C Routines Reference
Technical support
Other sources of information
Sybase certifications on the Web
Sybase EBFs and software maintenance
Accessibility features
What’s New in EAServer
New features in EAServer 5.3
Merge of Axis 1.2
Named classloader support
Oracle 10g support
jConnect 6.0 support
JDK 1.5 support
Unicode datatype support
Upgrade to Eclipse 3.0.1
Upgrade to Adaptive Server Anywhere 9.0.2 (ASA 9.0.2)
New features in EAServer 5.2
Automatic performance tuning
EAServer Manager enhancements
In-memory mirror caching
FIPS and TLS support
New features in EAServer 5.1
EAServer Manager enhancements
Preferences dialog
New wizards
Log file viewer enhancements
Importing and exporting a single component
Web application synchronization enhancement
Instance pool monitoring
Running components externally
IPV6 support
Server performance monitoring
Custom class loader enhancements
Systems Management
The EASDefault Web application
Jagtool enhancements
Web application synchronization enhancement
New flushstaticpage command
Alternate Solaris Java threading model
Private UDDI registry security enhancements
New features in EAServer 5.0
EAServer Manager enhancements
New wizards
Undeployment of packages, Web applications, and applications
HTTP directory browsing
EAServer Transaction Manager
Java Connection Management enhancements
Enhanced systems management support
Enhanced Solaris C++ compiler support
Server logging enhancements
Logging APIs
Managing log profiles
Runtime monitoring enhancements
Admin role granularity
Web Services Toolkit
jagtool enhancements
PowerDynamo Web site conversion utility
Servlet response caching improvements
Partial page caching
New Features in EAServer Versions 4.2.3, 4.2.2, 4.2.1, and 4.2
New features in version 4.2.3
Server stack size
Sharing of JSP class files
Suppressing SSL error messages
Servlet authenticated session enhancement
Jagtool enhancements
Installing and removing service components
Retrieving runtime monitoring statistics
New jmsmanage_selectors command
New jmsmanage_listeners command
Web server redirector enhancements
Support for Netscape Enterprise Server 6.1
New Web application property
Custom error page for redirector
New features in version 4.2.2
Netegrity SiteMinder Integration
Custom security component API changes
Support for multiple JAAS configuration file sections
Retrieving additional user session details in a JAAS login module
Retrieving HTTP session information in a custom authentication service
Supporting external single sign-on providers
Changing the effective user ID for the server process
Multiple listener hosts
Standalone jagtool
Enhanced Windows service support
Adaptive Server Enterprise wide table support
Enhanced character set support
Apache Web server redirector supports EAPI
New EJB CMP component properties
CMP isolation level
Table-level timestamps
Soft locking
Generated entity bean subclasses
EJB session bean passivation
Message service enhancements
New features in version 4.2.1
Web application form login enhancements
EJB pass-by-reference support
Database set-proxy support for EJB CMP entity beans
SSL connection troubleshooting enhancement
New features in version 4.2
In-memory HTTP session replication
Pooled component destruction
New Features in EAServer Versions 4.1.3, 4.1.2, 4.1.1, and 4.1
New features in version 4.1.3
Performance tuning features
Lightweight EJB container
CMP JDBC wrapper drivers
Thread monitors
Entity instance caching with Oracle
New server properties
New connection cache properties
HTTPS support for Web server plug-ins
Jagtool merge_props command
Java connection manager API change
New features in version 4.1.2
JDK 1.4
New performance tuning features
Connection request pool size (Solaris only)
Flow control
Servlet buffer pool
Servlet Java cache
Direct-access pseudocomponents
JavaServer Pages compilation speed
jagtool enhancements
Client connection timeouts
Web server redirector plug-in configuration
Web application authentication
APPLET context parameter for EJB clients
Web application character set properties
HTTP session attribute API change
New features in version 4.1.1
Message Bridge for Java enhancements
Java Secure Sockets Extension support
Named instance pools
New features in version 4.1
EJB 2.0 container-managed persistence enhancements
Web services support
Message Bridge for Java™
Deployment enhancements
Web server redirector for Microsoft Internet Information Server
HTTP response caching enhancements
Connection caching enhancements
jagtool enhancements
Servlet and Web application interface changes
Maintaining authenticated sessions
EJB 2.0 component behavior in EAServer 4.0 versus 4.1
New Features in EAServer 4.0
J2EE 1.3 support
Performance enhancements
JDK 1.3 and Hotspot VM integration
Servlet response caching
Entity component instance and query caching
In-memory state replication for stateful session components
EJB 2.0 support
Message-driven beans
Home interface methods
Local interfaces
EJB 2.0 interoperability
CMP enhancements
Message service enhancements
Java Message Service API support
Message-driven bean support
EAServer Manager enhancements
Servlet, JSP, and Web application enhancements
Servlet filters and application lifecycle event handlers
JSP 1.2 support
Standard extensions
Web server redirector plug-in
Java XML parser integration
J2EE connectors
J2EE naming enhancements
J2EE security enhancements
Enhanced transaction support
HTTP 1.1 support
Enhanced C++ component support
Java deployment enhancements
New custom class loaders
Deployment and code generation performance
Systems management enhancements
Server and EAServer Manager start-up scripts
Globally available connection caches
Java class file consolidation
Automated installation and configuration tools
Repository versioning
Cookbook
About this book
Getting Started with EAServer
Understanding EAServer
Starting the server
Starting servers on Windows platforms
Starting the server on UNIX platforms
Using EAServer Manager
Starting Sybase Central on Windows
Starting Sybase Central on UNIX platforms
Connecting to the EAServer Manager plug-in
Shutting down, restarting, or refreshing the server
Creating CORBA Java Components and Clients
Overview of the sample application
Tutorial requirements
Java compiler scripts
Creating the application
Start EAServer and EAServer Manager
Define a package, component, and method
Define a new package
Define and install a new component
Define the multiply method
Generate stubs and skeletons
Write the server-side code
Create the client program
Run the client program
Creating an applet client
Verify that your browser can run JDK 1.2 applets
Prepare your EAServer installation to run applets
Write the applet code
Create an HTML page to run the applet
Run the applet
Debugging
Creating C++ Components and Clients
Overview of the sample application
Tutorial requirements
Creating the application
Verify your environment
Start EAServer and EAServer Manager
Define a package, component, and method
Define a new package
Define and install a new component
Define the multiply method
Generate stubs, skeletons, and implementation templates
Write the server-side code
Write the client-side code
Compile the client executable
Run the client executable
Creating Enterprise JavaBeans Components and Clients
Overview of the sample components
Tutorial requirements
Creating the application
Start EAServer and EAServer Manager
Create the package and components
Define a new package
Define the Glossary entity bean
Define the Query stateless session bean
Generate stubs and skeletons
Create the glossary database and connection cache
Start the glossary database server
Create the connection cache and associate it with the components
Create the client application
Run the client application
Using the EAServer Samples
Samples in the EAServer installation
Java samples
Using JavaServer Pages and EJB components
Using EJB CMP entity beans
Using message-driven beans and JMS
Using SSL in Java clients
Using custom authentication
Using the Java Authentication and Authorization API
Using CORBA components and clients
Systems management
C++ samples
Using SSL in C++ clients
Using custom authentication services
Inspecting client SSL credentials
Java Pet Store
PowerBuilder samples
Web Services Toolkit samples
Samples on the Sybase Web site
System Administration Guide
About this book
Getting Started
Starting the Jaguar server
Using EAServer Manager
Starting EAServer Manager
Disconnecting from EAServer
Administration password and OS authentication
Shutting down a server
Verifying your environment
Sybase Central Overview
Overview
Start-up options
EAServer Manager
Profile Manager
Certificates folder and the standalone Security Manager
Keyboard navigation
Creating and Configuring Servers
Creating or deleting a server
Configuring servers
General
Java VM
HTTP Config
Configuring redirection addresses when using a proxy server
HTTP logging and statistics
Transactions
Resources
Log/Trace
Handlers
Naming Service
Naming server options
Naming server strategy
Servlets
PowerDynamo
Hot Standby
JAXP Support
Java Classes
Java Debug
Static Page Caching
HTTP Custom Response Header
HTTP Directory Browsing
Components
Advanced
Configuring listeners
Preconfigured listeners
Listener failover
Creating and configuring listeners
Starting the server
Changing the effective user ID of the server process
Using the JagRepair server
Configuring log profiles
Configuring the server’s log profile
Configuring log profiles
Category names
Category properties
Handler properties
Formatter properties
Using log profiles in Java client applications
Configuring server stack size
IPV6 support
Server support for IPV6
Client support for IPV6
Using Admin mode
Putting servers into Admin mode
Switching to Ready mode
Creating clients that connect to Admin mode servers
Operating system configuration
Database Access
Connecting to databases
Sybase Adaptive Server Anywhere
Sybase Adaptive Server Enterprise and gateways
Oracle databases
Other databases
Configuring connection caches
General properties
About JDBC connection URLs
About ODBC data source names
Caching properties
Driver properties
XA properties
SQL tracing properties
Advanced tab
JDBC driver properties
Client-Library connection settings
Database type setting
Connection cache refresh
Connection cache ping
Using XA resources with Adaptive Server Enterprise
Modifying the Adaptive Server configuration files
Configuring connectors
Configuring Adaptive Server Enterprise connections
For Sun Solaris and SGI
Displaying current soft and hard limits
Increasing the soft limit
Increasing the hard limit
For Compaq Tru64
For HP-UX
Sample program
Naming Services
How does the EAServer naming service work?
EAServer initial context
Name binding example
Transient versus persistent storage
CORBA CosNaming API support
Binding names
Resolving EAServer objects
Resolving objects using the CosNaming interface
Interoperable naming
Network name service
JNDI support
JNDI J2EE features
Environment properties
EJB references
Resource factory references
UserTransaction references
Configuring the EAServer naming service
Name binding password security
Using an LDAP server with EAServer
LDAP object schema and EAServer objects
Storing EAServer object bindings on an LDAP server
Clusters and Synchronization
Cluster overview
Cluster servers
Configuring a cluster
Heartbeat detection
Cluster start-up options
Synchronization
Component synchronization
Package synchronization
Servlet synchronization
Application synchronization
Web application synchronization
Synchronization procedures
Load Balancing, Failover, and Component Availability
Understanding load balancing
Load metrics
Load distribution policies
Interoperable object references
Understanding high availability
Configuring load balancing
Deploying components to a cluster
Stateful components
Partitioned components
Automatic failover for components
Component implementation guidelines
Deploying Web applications to a cluster
Clustered Web application requirements
Configuring in-memory HTTP session replication
Configuring persistent session storage
Creating the database table
Implementing Sybase Failover for high availability systems
Java Connection Management
JDBC 1.0 and 2.0
JDBC 2.0 extension/JTA drivers
Troubleshooting the database connection
Open Client Client-Library
Modifying the client connection information
Selecting the high availability option
Using the connection APIs
Setting up the Message Service
Configuring the message service
Configuring the message service to use non-ASCII characters
Adding and configuring the message service parts
Permanent destinations
Connection factories
Message selectors
Listeners
Access roles
Thread pools
Dead queue
Viewing messages and statistics
Importing and Exporting Application Components
Deploying packages and components
Importing and exporting components in EAServer JAR format
Importing and exporting packages in EJB-JAR format
Exporting EJB-JAR files
Deploying Web applications
What is created during import
Deploying J2EE applications
What is created during import
Deploying application clients
Deploying connectors
Deploying other entity types
Using EAServer configuration files in J2EE archives
Merging property files in EAServer JAR archives
Creating merge files
Creating cleaner files
Deleting packages, Web applications, and applications
Using Repository Versioning
Introduction
Creating and restoring versions
Runtime Monitoring
Using the File Viewer
Using the Runtime Monitor
Monitoring component activity
Monitoring connection caches and managed connection factories
Monitoring network connections
HTTP and IIOP statistics
Connected users
HTTP history
Using the OTS Transaction Monitor
Using jagtool and jagant
Working with jagtool
jagtool syntax
Local versus connected mode
Using connected mode
Using local mode
Entity identifiers
jagtool and jagant
Setting up your environment
jagant scripts
jagant syntax
The Ant build file
Registering jagtool commands in the Ant build file
Using the jag_connect command
Using jagant in connected mode
Using jagant in local mode
Using multiple connections
XML configuration files
Format of the XML configuration file
sybase-easerver-config element
macro elements
configure elements
property elements
Special characters
Sample configuration file
jagtool commands
compilejsp
configure
copy
create
delete
deploy
ejbref
enventry
exists
export
exportconfig
flushstaticpage
gen_skels
gen_stubs
gen_stubsandskels
gen_tlbreg
getmonitorstats
getserverinfo
getservicestate
grantroleauth
install
jmscreate
jmsdelete
jmsflush
jmslist
jmslist_listeners
jmslist_messages
jmsmanage_listeners
jmsmanage_selectors
jmsprops
jmsset_props
list
list_ver
merge_props
ping
props
rebind
refresh
remove
removeroleauth
resref
restart
restore_ver
save_major_ver
save_minor_ver
set_admin
set_props
set_ready
setjagadminpasswd
shutdown
sync
Using Systems Management
Overview
Systems Management functionality
JMX agent
Service MBeans
Service proxy MBeans
Events
MIB manager MBeans
Adapters and connectors
JMS forwarding
EAServer proxy MBean
SNMP proxy MBean
SNMP functionality
SNMP master agent
SNMP management console
SNMP MIBs
NETWORK-SERVICES MIB
J2EE MIB
SNMP MIB implementation details
Running the JMX agent
Connecting to the JMX agent
Creating services
Creating service MBeans
Creating services
Running the samples
Compiling the samples
Using SSL
Setting up SSL
Using the Systems Management Console
Connecting to the Systems Management Console
The user interface controls
Navigating the tree view
The details view
Performing actions
Managing user roles
Managing access to services
Accessing MBeans
sybase.system:Name=Master
sybase.system.jms:Type=Forwarder
sybase.system.adaptor.security:Name=UserPassword
sybase.system.logger:Type=File
sybase.system.log4j:Type=Notifier
sybase.system.service:Name=Jaguar,Type=EAS
Using EJB 1.0 JAR Support
Importing and exporting EJB 1.0 JAR files
EJB 1.0 deployment descriptor properties
BeanName tab
Access Control tab
Control Descriptor tab
Environment tab
Repository Properties Reference
About these reference pages
User-defined properties
Encrypted properties
“See also” headings
Application properties
Application client properties
Cluster properties
Component properties
Connection cache properties
Connector properties
Database type properties
EJB local reference properties
EJB reference properties
Entity collection properties
Environment properties
Filter properties
Instance pool properties
JMS entity properties
Listener properties
Log profile properties
Log profile EAS subsystem properties
Log profile Java Logging subsystem properties
Log profile Log4j subsystem properties
Method properties
Package properties
Resource environment reference properties
Resource manager properties
Resource reference properties
Role properties
Security properties
Server properties
Servlet properties
Thread monitor properties
Web application properties
Programmer’s Guide
About this book
Creating Component-Based Applications
Application architecture
Designing the EAServer application
Implementing components and clients
Deploying the application
Deploying components
Deploying clients
Understanding Transactions and Component Lifecycles
Component lifecycles
EAServer’s transaction processing model
How EAServer transactions work
Benefits of using EAServer transactions
Defining transactional semantics
Example
Dynamic enlistment in bean-managed transactions
Entity bean local diamonds
EAServer Transaction Manager
Resource recovery and transaction logging
Recovering XA resources registered by user components
Transaction interoperability
Resource manager
Enlisting XA resources with Transaction Manager
Managing Applications and Packages in EAServer Manager
Defining applications
Creating and installing applications
Deleting and removing applications
Configuring application properties
Application properties: General
Application properties: Role Mapping
Application properties: Java Classes
Application properties: Additional Files
Application properties: JAXP Support
Application properties: Security
Application properties: Advanced
Defining packages
Creating a new package
Installing packages to a server
Modifying packages
Configuring package properties
Package properties: General
Package properties: Java Classes
Package properties: Additional Files
Package properties: Role Mapping
Package properties: JAXP Support
Package Properties: Advanced
Defining Components
Defining components
Installing components
Configuring component properties
Component properties: General
Component properties: Transactions
Component properties: Instances
Component properties: Environment
Component properties: EJB Local Refs
Component properties: EJB Refs
Component properties: Resource Refs
Component properties: Resource Environment Refs
Component properties: Role Refs
Component properties: Resources
Component properties: Persistence
Component properties: Run-As Identity
Component properties: Run-As Mode
Component properties: Java Classes
Component properties: Additional Files
Component properties: JAXP Support
Component properties: Advanced
Running components externally
Configuring components to run externally
Configuring servers to host external components
Defining Component Interfaces
Defining interfaces graphically
Editing interfaces
Method properties
Parameter properties
Parameter and return value datatypes
Importing interfaces from compiled Java files
Coding classes, interfaces, and JavaBeans for import
Importing a Java class or interface in EAServer Manager
Importing interfaces from registered ActiveX components
Defining modules, interfaces, and types in IDL
Learning IDL
Creating and editing IDL modules, interfaces, and types
Using the IDL editor window
Creating and editing interfaces
Adding IDL documentation comments
Refreshing the HTML documentation
Viewing HTML documentation for IDL modules
Importing existing IDL modules
Enterprise JavaBeans Overview
About Enterprise JavaBeans components
EJB component types
Stateful session beans
Stateless session beans
Entity beans
EJB transaction attribute values
EJB container services
EAServer EJB support
Running EJB components in EAServer
EJB clients connecting to EAServer
For more information
EJB 2.0 differences from 1.1
Message-driven beans
Home interface methods
Local interfaces
CMP enhancements
EJB 2.0 interoperability
EJB 1.1 differences from EJB 1.0
Component differences
JNDI names in deployment descriptors
Environment properties
EJB and resource references
Security access-control changes
Transaction isolation level
Client model differences
Creating Enterprise JavaBeans Components
Defining an EJB component
Defining the primary key type
Defining home interface methods
Defining remote interface methods
Defining local interfaces
Configuring the component properties
Configuring EJB references
Configuring resource references
Configuring role references and method permissions
Configuring environment properties
Deploying the component classes
Creating Enterprise JavaBeans Clients
Developing an EJB client
Generating EJB stubs
Instantiating home interface proxies
Obtaining an initial naming context
Resolving JNDI names
Instantiating remote or local interface proxies
Calling remote interface methods
Calling local interface methods
Managing transactions
Serializing and deserializing bean proxies
Runtime requirements
EAServer EJB Interoperability
Intervendor EJB interoperability
Interoperable naming URLs
Interoperable naming URLs for EJB clients
Interoperable naming URLs for EJB references
Classes for RMI/IIOP connections from third-party containers
Invoking non-EJB components from EJB clients
Invoking EJB components from CORBA C++ clients
Invoking EJB components from PowerBuilder clients
Invoking EJB components from ActiveX clients
Supported datatypes
About overloaded methods and nested IDL
Using the home interface
Serializing and deserializing instance references
Invoking EJB components from CORBA Java clients
Invoking EJB components using the MASP interface
Creating Application Clients
Creating an application client
Configuring application client properties
General properties
EJB references
Resource references
Resource environment references
Environment properties
Java classes
JAXP properties
Application client files
Running application clients
Setting up a client’s workstation
Starting the runtime container
Creating CORBA Java Components
Requirements
Procedure for creating Java components
Define the component interface and properties
Choose implementation datatypes
Write the Java source file
Generate stub, skeleton, and implementation files
Add package import statements
Code the constructor
Implement control interface methods
Add error handling code
Advanced techniques
Issue intercomponent calls
Manage database connections
Return result sets
Access SSL client certificates
Set transactional state
Retrieve user-defined component properties
Deploy Java components
Debug Java components
Creating CORBA Java Clients
Overview
Procedure for creating CORBA-compatible Java clients
Generating Java stubs
Instantiating proxy instances
Executing component methods
Cleaning up client resources
Serializing component instance references
Handling exceptions
Deploying and running Java clients
Instantiating proxies with the CosNaming API
Using other CORBA ORB implementations
Connecting to EAServer with a third-party client ORB
Connecting to third-party ORBs using the EAServer client ORB
CORBA C++ Overview
Overview
Requirements
Supported datatypes
Mapping for predefined EAServer Manager datatypes
Using mapped IDL types
Overloaded methods
Creating CORBA C++ Components
Procedure for creating C++ components
Defining C++ components
Generating required C++ files
Writing the class implementation
Write methods
Returning result sets
Error handling
Managing explicit OTS transactions
Accessing SSL client certificates
Issuing intercomponent calls
Compiling source files
Compiling on UNIX platforms
Compiling on Windows
Visual C++
Debugging C++ components
Running C++ components externally
Limitations
Configuring a component to run externally
Building and deploying the external component executable
Creating C++ components for multiplatform clusters
Creating CORBA C++ Clients
Procedure for creating CORBA C++ clients
Generating stubs
Writing CORBA C++ clients
Adding required include and namespace declarations
Instantiating stub instances
Configure and initialize the ORB runtime
Creating a Manager instance
Creating sessions
Creating stub instances
Invoking methods
Processing result sets
Example of processing result sets
Retrieving the result set
Iterating through the rows and columns
Retrieving the column datatype and processing values
Handling exceptions
CORBA system exceptions
User-defined exceptions
Compiling C++ clients
Deploying C++ clients
Using the CosNaming interface
Configure and initialize the ORB for CosNaming use
Obtain an initial naming context
Obtaining the initial context
Introduction to CosNaming name resolution
Resolving component proxies
Using CORBA ORB implementations other than EAServer
Connecting to EAServer with a third-party client ORB
Generating compatible C++ stubs
Instantiating components using a third-party ORB
Connecting to third-party ORBs using the EAServer client ORB
Creating PowerBuilder Components
Creating PowerBuilder Clients
ActiveX Overview
Overview
Requirements
ActiveX component requirements
ActiveX client requirements
ActiveX datatype support
Structure support
Union support
About IDL unions
Supported discriminator and field types
ActiveX mapping for unions
Sequence support
IDL typedef support
IDL enumeration support
Result-set support
Algorithm to retrieve result sets
Creating ActiveX Components
Procedure for creating ActiveX components
Defining ActiveX components
Importing ActiveX components
Procedure
Defining methods
Defining return and parameter datatypes
Defining the transaction property
Defining instance properties
Writing ActiveX components
Implementing a constructor and destructor
Sharing data between components
Using shared data in C++
Using shared data IDispatch interfaces
Issuing intercomponent calls
Managing database connections
Sending result sets from an ActiveX component
Setting transactional state
Adding error-handling code
Deploying ActiveX components
Creating ActiveX Clients
Procedure for creating ActiveX clients
Generate .tlb and .reg files for components
Before you start
Check the ProgID for each interface
Generating TLB/REG files
Files generated
Develop and test the ActiveX client
Instantiating proxies using CORBA-style interfaces
Initializing the ORB
Creating a Manager instance
Creating sessions
Creating stub instances
Instantiating stub instances using the EAServer 1.1 interface
Declare proxy objects
Set connection properties
Instantiate server components
Invoke component methods
Code exception handling
Using an ActiveX error handler
Handling exceptions inline
Deploy the ActiveX client
Creating Web Applications
What is a Web application?
Contents of a Web application
Servlet files
JSP files and tag libraries
Static files
Java classes
Class and JAR file locations
Which classes are loaded by the custom loader?
Deployment descriptor
Creating Web applications
Configuring Web application properties
General properties
Context initialization properties
Welcome and error page specifications
Welcome files
Error pages
Tag library descriptor references
Naming references
EJB references
EJB local references
Resource references
Resource environment references
Environment properties
Request path mappings
MIME mappings
JAXP properties
Java Classes properties
Extensions properties
Additional files
Security properties
Page Caching properties
Listener properties
Filter Mapping properties
The EASDefault Web application
Using Java extensions
Installing extensions in EAServer
Defining required extensions for Web applications
Defining required extensions in EAServer Manager
EAServer Java extension properties
Defining required extensions in the WAR manifest file
Localizing Web applications
Enabling accept-language header parsing
Internationalization for servlets
Deploying localized static files
Language selection algorithm
Localizing JSP content
Creating Java Servlets
Introduction to Java servlets
Writing servlets for EAServer
Connection caching
Component invocations
Threading
Logging
Error pages
Request dispatching
URL interpretation
Implementation
Static content
Response buffering
Encoding responses and double-byte characters
Installing and configuring servlets
Installing servlets
Defining a new servlet
Installing existing servlets into a server
Uninstalling servlets from a server
Deleting servlet definitions
Configuring servlet properties
Deploying and refreshing servlet classes
Deploying servlet classes
Refreshing servlets
Starting and stopping servlets
Web application support
Adding servlets to a Web application
Server properties for servlets
Using Filters and Event Listeners
Servlet filters
Custom headers
Application lifecycle event listeners
Creating JavaServer Pages
About JavaServer Pages
How JavaServer Pages work
What a JSP contains
Why use JSPs?
Syntax summary
Directives
Scripting elements
Comments
Standard tags
Objects and scopes
Scopes
Implicit objects
Application logic in JSPs
Error handling
Using JSPs in EAServer
JSP and EAServer overview
JSP 1.2 highlights
Compiling JSPs
JSP file locations
Saving Java source code
Source and class file locations
Creating and configuring JSPs in EAServer
Internationalization
Mapping JSPs
Page caching
Filters
Sending Result Sets
Overview
Sending result sets with Java
Forwarding a ResultSet object
Sending results row-by-row
JServerResultSet sequence of calls
JServerResultSet example
Sending result sets from a PowerBuilder component
Sending result sets from an ActiveX component
Forwarding a result set with ResultsPassthrough
Sending results row-by-row
Result sets row-by-row: C++ example
Sending result sets from a C or C++ component
Forwarding a result set with JagResultsPassthrough
Sending results row-by-row
Using Connection Management
Overview of connection management
When to use Connection Manager
Connection caches and security
Defining connection caches
JDBC DataSource lookup
Application authentication
Using Java Connection Manager classes
Classes
Java Connection Manager example
Using Connection Manager routines in C, C++, and ActiveX components
ODBC connection caches
Header files
Data structures
ODBC example
Single-threading ODBC calls on UNIX
Client-Library connection caches
Header files
Data structures
Client-Library example
Client-Library error and message callbacks
Oracle connection caches
Oracle autocommit setting
Using OCI 7.x connection caches
Using OCI 8.x connection caches
Using OCI 9.x connection caches
Using cached connections in PowerBuilder components
Connection Manager guidelines
Avoiding results-pending errors
Connections and cache handles
Maintaining connection state
Creating Entity Components
Implementing entity components
Coding to support manual persistence
Understanding the automatic persistence architecture
Configuring automatic or EJB CMP persistence
Specifying the CMP version for EJB 2.0 entity beans
Setting Persistence/General subtab properties
Enabling automatic key generation
Creating database tables
Configuring concurrency control
Setting field-mapping properties
Specifying finder- and ejbSelect-method queries
Configuring table-mapping properties
Using relationship components
Configuring Persistence for Stateful Session Components
How it works
Supported component implementations
Using EJB activation and passivation
Configuring stateful session beans to support failover
Configuring passivation after timeout
Using automatic persistence
Defining the IDL state type
Accessing the state data in the implementation
Configuring Persistence Mechanisms
Storage components
Supported Java, IDL, and JDBC/SQL types
Table schema for binary storage
Requirements for in-memory stateful failover
Cluster configuration for in-memory failover
Mirror Cache tab component properties
Configuring Custom Java Class Lists
Understanding how the class loader works
Class loader versions
The class loader hierarchy and delegation policy
The system class loader
Deciding which classes to add to the custom list
Custom class lists for Java and EJB components
Class loading order for components
Custom class lists for Web applications
Class loading order for Web applications
Custom class lists for servlets installed directly in the server
Custom class lists for packages, applications, or servers
Configuring an entity’s custom class list
Troubleshooting class loader configuration issues
Commonly encountered problems
Custom class loader tracing
JAR file locking and copying
Using the Message Service
Overview
High availability and load balancing
Message security
Reliable delivery
Scalable notification
Transaction management
Developing JMS applications
Creating a JMS InitialContext object
Looking up a ConnectionFactory object
Creating permanent destinations
Creating connections
Creating sessions
Creating message producers
Creating message consumers
Filtering messages using selectors
Implementing and installing message listeners
Message-driven beans
Creating messages
Sending messages
Publishing messages
Receiving messages
Browsing messages
Enabling JMS tracing
Closing connections, sessions, consumers, and producers
JMS interfaces not supported
Developing EAServer messaging service applications
Obtaining CtsComponents::MessageService object references
Creating message consumers
Creating message selectors
Creating thread pools programmatically
Implementing and installing message listeners
Sending messages
Publishing messages
Receiving messages
Subscribing to scheduled messages
EAServer message service CORBA API
Using the Thread Manager
About the Thread Manager
The Thread Manager and service components
The Thread Manager and the message service
Thread Manager interface documentation
Using the Thread Manager
Before you start
Adapting components to be run by the Thread Manager
Understanding thread groups
Understanding the run interval
Understanding the thread count
Instantiating the Thread Manager
Obtaining authorized access
Instantiating a proxy
Starting threads
Suspending and resuming execution
Stopping threads
Creating Service Components
Introduction
Creating service components
Define the component interface and properties
Service component properties
Required client roles
Implement GenericService interface methods
Java example of GenericService methods
C++ example of GenericService methods
Implement other required methods
Install the component as an EAServer service
Determining service state
Refreshing service components
Creating and Using EAServer Pseudocomponents
Benefits of pseudocomponents
Creating pseudocomponents
Implementation restrictions
Defining a pseudocomponent
Properties for a Java pseudocomponent
Properties for a C++ pseudocomponent
Direct-access pseudocomponent stubs and skeletons
Instantiating pseudocomponents
Pseudocomponent object URLs
Identifying a C++ pseudocomponent
Identifying a Java pseudocomponent
Instantiating pseudocomponents from Java
Instantiating pseudocomponents from C++
Instantiating pseudocomponents from PowerBuilder
Debugging C++ pseudocomponents
Creating JavaMail
Introduction to JavaMail
Writing JavaMail for EAServer
Creating a JavaMail session
Constructing a message
Sending a message
Sample EAServer JavaMail program
JavaMail providers
Deploying JavaMail-enabled applications
Configuring Java XML Parser Support
About JAXP
Configuring JAXP properties in EAServer Manager
Exporting and importing application clients
Executing Methods As Stored Procedures
Creating invocation commands
Limitations
Using MASP from isql
Using MASP from application builder tools
PowerBuilder
PowerDynamo
Other tools
Configuring the return status
Migrating Open Server Applications to EAServer
Migration overview
Coding changes and examples
Modifying main
Open Server properties
Making your code thread-safe
DLLs, shared objects, and makefiles
Modified APIs and new event handlers
Modified APIs
Event handler prototypes
EAServer configuration
Installing event handlers
Specifying event handlers
Configuring an Open Server listener
Additional event handler information
Calling convention for event handlers
Initialization, run, start and exit events
Start handler template
Exit handler template
Connect and disconnect handlers
Connect handler
Disconnect handler
Build with the Visual C++ IDE
A sample module definition (.def) file
Creating C Components
C component lifecycle
Requirements
Procedure for creating C components
Define component interface and properties
Define the component’s interfaces
Transaction property
Instance properties
Generate C component files
Procedure for generating C component files
File naming conventions
Regenerate changed C component methods
Write C components
Define implementation functions
Implementation function return codes
Calling conventions
Parameter datatypes
Logical method return values
Implementing the method behavior
Components that require instance specific data
C components that are wrappers for C++ classes
Methods that interact with remote database servers
Methods that return row results
Share data between C or C++ components
Procedure for sharing data
Create shared variables and collections
Lock and unlock collections
Read and update shared variables
Release shared variable and collection references
List all collections
Methods that set transactional state
Customize the creation and destruction of components
create routine
destroy routine
Handle errors in your C component
Compile C components
Build on UNIX
Build on Windows
DLLs for C components
Build with the Visual C++ IDE
The module definition (.def) file
Debug C components
Using the Command Line IDL Compiler
com.sybase.CORBA.idl.Compiler
API Reference Manual
About this book
Java Classes and Interfaces
Package index
com.sybase.CORBA.jdbc102
com.sybase.CORBA.jdbc11
com.sybase.jaguar.jcm
com.sybase.jaguar.server
com.sybase.jaguar.sql
com.sybase.jaguar.util
com.sybase.jaguar.util.jdbc102
com.sybase.jaguar.util.jdbc11
com.sybase.CORBA.jdbc11.IDL class
com.sybase.CORBA.jdbc11.IdlResultSet
com.sybase.CORBA.jdbc11.SQL class
jaguar.jcm.JCM class
jaguar.jcm.JCMCache class
jaguar.jcm.JConnectionNotFoundException class
jaguar.server.Jaguar class
jaguar.server.JContext class
jaguar.sql.JServerResultSet interface
jaguar.sql.JServerResultSetMetaData interface
jaguar.util.JException class
jaguar.util.<object>Holder class
jaguar.util.jdbc102.<object>Holder class
jaguar.util.jdbc11.<object>Holder class
ActiveX C++ Interface Reference
Header files and link libraries
List of interfaces
GetObjectContext routine
IJagServer interface
IJagServerResults interface
IObjectContext interface
IObjectControl interface
ISharedProperty interface
ISharedPropertyGroup interface
ISharedPropertyGroupManager interface
ActiveX IDispatch Interface Reference
How to use these reference pages
IDispatch interface index
IJagServer interface
IJagServerResults interface
SharedProperty interface
SharedPropertyGroup interface
SharedPropertyGroupManager interface
ActiveX Client Interfaces
How to use these reference pages
Interface index
Field interface
Fields collection
JagORBClientErrNum enumeration
JagORBSrvErrNum enumeration
JCollection interface
Object interface
Orb interface
RecordSet interface
C Routines Reference
Alphabetical list of all routines
Routines for managing component instance data
Routines for managing transaction flow
Routines for sharing data between components
Routines for managing cached connections
Routines for sending result sets
Routines for handling errors in C or C++ components
Routines for managing memory in C or C++ components
Routines to obtain user login information
JagAlloc
JagBeginResults
JagBindCol
JagCmCacheProps
JagCmGetCachebyName
JagCmGetCachebyUser
JagCmGetConnection
JagCmGetCtx
JagCmGetProxyConnection
JagCmReleaseConnection
JagColAttributes
JagCompleteWork
JagContinueWork
JagDescribeCol
JagDisallowCommit
JagEndResults
JagFree
JagFreeCollectionHandle
JagFreeCollectionList
JagFreeSharedDataHandle
JagGetCollection
JagGetCollectionList
JagGetHostName
JagGetInstanceData
JagGetPassword
JagGetPeerAddress
JagGetSharedData
JagGetSharedDataByIndex
JagGetSharedValue
JagGetUserName
JagInTransaction
JagIsRollbackOnly
JagLockCollection
JagLockNoWaitCollection
JagLog
JagNewCollection
JagNewSharedData
JagNewSharedDataByIndex
JagResultsPassthrough
JagRollbackWork
JagSendData
JagSendMsg
JagSetInstanceData
JagSetSharedValue
JagSleep
JagUnlockCollection
Deprecated Java Classes and Interfaces
Package Index
com.sybase.jaguar.beans.enterprise
jaguar.beans.enterprise.EnterpriseBeanException class
jaguar.beans.enterprise.InstanceContext interface
jaguar.beans.enterprise.ServerBean interface
jaguar.beans.enterprise.SharedObjectException class
jaguar.beans.enterprise.SharedObjects interface
Performance and Tuning Guide
About this book
Introduction
Determining factors
Response time
Scalability and throughput
Memory use
Threading
Measurement and diagnosis tools
Instrumented code
Profiling software
Load-testing tools
Memory and CPU usage monitors
EAServer monitoring and tracing tools
Runtime monitoring with EAServer Manager
Runtime monitoring APIs
Trace-logging options
The tuning process
Server Tuning
The performance tuning wizard
General server tuning
Thread settings
Number of threads
Thread stack size
Solaris Java thread model
Flow control
Debug and trace settings
Java virtual machine tuning
CLASSPATH and BOOTCLASSPATH settings
Custom class lists
Java VM type and version
Just-in-time compilation
JVM memory allocation parameters
Other Java VM settings and troubleshooting
Listener tuning
HTTP keep alive
HTTP maximum requests
Connection request pool size
SSL session caching
Operating system settings
UNIX file descriptors
Per-process memory limits
Factors that affect start-up and shutdown time
Start-up performance
Shutdown performance
Pooled component destruction
Servlet destruction
EAServer memory requirements
Component Tuning
Running the performance tuning wizard
Common component performance issues
Tracing and debugging settings
Thread-related issues
Bind thread
Concurrency
Sharing
Thread monitors
Stateful versus stateless components
Instance pooling
Configuring component instance pool properties
Named instance pools
Optimizing intercomponent calls
Java component performance
EJB component performance
Optimizing in-server EJB calls
Local interfaces
Lightweight container
Pass-by-reference semantics
Entity bean read-only methods
Entity bean database update frequency
Stateful session beans
C++ component performance
PowerBuilder component performance
Settings that affect system resource use
DataStore row height size
Web DataWindow settings
EJB CMP Tuning
Generated entity bean subclasses
Creating and tuning database tables
Automatic key generation settings
Concurrency control options
Enabling PCC
Enabling OCC
Configuring OCC options
Enabling automatic transaction retry
Configuring CMP isolation level
Using soft locking
Connection cache settings
Tuning the cache size and database type
Using CMP JDBC wrapper drivers
Entity instance and query caching
Cache architecture
Cache coherency and transaction consistency
Configuring object caching
Enabling query caching
Configuring transaction local cache settings
Enabling database change notification
Sample script for database stored procedures
Customizing the implementation
CMP runtime monitoring
Web Application Tuning
Using the performance tuning wizard
Tuning server and Web application settings
Tracing properties
Session timeouts
Class loader settings
Servlet buffer pools
Clustered deployments
HTTP and HTTPS listener configuration
SSL and performance
Tuning servlet and JSP settings and code
Use local interfaces for EJB calls
Threading
Preloading classes
JSP compilation options
Precompiling JSPs
JSP file timestamp checking
Runtime compilation settings
Understanding HTTP response caching options
Static page caching
Servlet response caching
Dynamic page caching
Configuring page caching for servlets and JSPs
Configuring Web application page caching properties
Caching an entire tree
Using page caching with filters that modify a response
Using the servlet Java cache
Using partial page caching
Using the caching tag library
The cache tag
The flushCacheByKey tag
The flushCacheByScope tag
Portability considerations
Using the caching API
Class CacheManager
Database Access Tuning
Component design and implementation
Keep transactions short
Minimize result set size
Use database server optimizations
Minimize use of two-phase commit
Clean up connections before releasing them to the cache
Avoid unnecessary database work
Server and component transaction settings
Transaction timeout
Transaction memory table size
Unexpected deadlock errors
Connection cache settings
Tuning the cache size
Monitoring cache activity
Disabling the cache size monitor thread
Tuning caches used by EJB CMP entity beans
Remove unused connection caches
Sanity checking
SQL tracing
Using the caching APIs
Dynamic prepare on jConnect caches
Database and driver specific settings
Cluster Tuning
When to use clusters
Cluster settings that affect performance
Heartbeat detection
Load balancing policy
IIOP client settings that affect load balancing
Web application settings
HTTP session replication mechanism
Lazy session validation
Component settings
Automatic failover
Component state replication
EJB CMP entity bean instance and query caching
Message Service Tuning
Best practices for coding
Global message service settings
Database and connection cache
Tracing
Other global settings
default.maximum
session.timeout
Queue and topic settings
REQUIRES_ACKNOWLEDGE
REQUIRES_TRANSACTION or SUPPORTS_TRANSACTION
Quality of protection
Tables for persistent messages
Queue size
Timeout settings
Thread pools
Shared listeners
The key log table
Using the Performance Monitor
How it works
Configuring memory thresholds
Configuring response rate thresholds
Component settings
Listener settings
Tuning response rate thresholds
Avoiding deadlock scenarios
Obtaining performance monitor statistics
Security Administration and Programming Guide
About this book
Security Concepts
Authentication and authorization
Public-key cryptography
Public-key certificates
SSL, HTTPS, and IIOPS
TLS and FIPS
Proxies and firewalls
Lines of defense
Types of attacks
Defense against attacks
Securing Component Access
Client authentication
Intercomponent authentication
Accessing SSL information
Non-EJB components
C++ components
Intercomponent authentication for EJBs and servlets
Intercomponent authentication for EJB 2.0 components
Caller propagation
Run-as support
Trusted identities
Authentication of component invocation from servlets
Caller propagation for servlets on remote servers
Run-as support
Quality of protection
Usage scenarios
Client authorization
Enterprise JavaBeans
EJB 2.0 authorization of methods with no defined permissions
Using Web Application Security
Introduction
Authentication
Form login requirements in a Web application when using HTTPS (SSL)
Web application direct form login
Authorization
Role mapping
Securing TDS Client Access
TDS and MASP listeners
MASP client security
Open Server client security
Using SSL in Java Clients
Using SSL in Java applets
Using SSL in Java applications
Requirements
Establishing a secure session
Using the SSLServiceProvider interface
SSL properties
Implementing an SSL callback
Retrieving session security information
Sample Java applications that use SSL
Creating HTTP and HTTPS connections in Java applications
HTTP connections
HTTPS connections
Installing the HTTPS protocol handler
EAServer’s HttpsURLConnection class
SSL properties
Using Java Secure Socket Extension classes
Possible solutions for JSEE issues
Using SSL in C++ Clients
Introduction
Initializing the SSL security service
ORB properties for secure sessions
Creating a manager instance
Retrieving session security information
Creating an SSL callback component
Using SSL in PowerBuilder Clients
Using SSL in ActiveX Clients
Requirements
Establishing a secure session
Using the SSLServiceProvider interface
SSL properties
Choosing a security characteristic
Secure server addresses
Other useful ORB properties
Implementing an SSL callback
Retrieving session security information
Example: inspecting SSL session properties
Example: inspecting X.509 certificate properties
Using TLS and FIPS in EAServer
Introduction
Compatibility with previous versions
Enabling TLS-secure listeners
Enabling FIPS
Enabling FIPS mode from EAServer Manager and Security Manager
Disabling TLS support
Upgrading the test CA and sample certificates
FIPS-related jagtool commands
FIPS mode for Java-side cryptography usage
Troubleshooting
Creating and Using Custom Security Components
Using a custom authentication service
Maintaining authenticated sessions
Retrieving HTTP session information
Using a custom role service
Creating a role service
Installing the role service
Using a custom authorization service
Deciding whether to use the authorization services and role service
Creating the authorization service
Installing the authorization service
Component URLs for the authorization service
Supporting external single sign-on providers
Netegrity SiteMinder Integration
Configuring your security scenario
Configuring the SiteMinder Policy Server
Configuring reverse-proxy access to EAServer
Enabling Policy Server logging
Configuring EAServer for SiteMinder security
Using the JAAS API
Introduction
Requirements
JAAS in EAServer
Enabling JAAS for a server
Retrieving additional user session details in a JAAS login module
JAAS on the client
JAAS for connectors
Samples and debugging
Deploying Applications Around Proxies and Firewalls
Connecting through proxy servers
Using Web proxies
Properties that affect Web proxy use
Using reverse proxies
Reverse-proxy configuration
Properties that affect reverse proxy use
Security Configuration Tasks
Configuring EAServer roles
Assigning users and groups to roles
Determining authorization
Predefined roles
Admin role in EAServer
Configuring OS authentication
Configuring OS user and group authorization
Configuring security profiles
Security characteristics
Defining security profiles
SSL session caching and reuse
Configuring listeners
Preconfigured listeners
Listener failover
Configuring listener properties
Configuring identities
Configuring identity properties
Identity properties/basic
Identity properties/SSL
Identity properties/Entrust
Managing Keys and Certificates
SSL overview
Managing keys and certificates on EAServer
EAServer Manager | Certificates folder management
Test CA management
Key management
Certificate management
Certificate file extensions and types
Using Netscape to manage certificates on the client
Installing Sybase PKCS #11 into Netscape 4.0x
Obtaining a key pair and certificate
SSL certificate information in servlets
Entrust PKI Integration
Overview
Scenarios
Both client and EAServer use non-Entrust certificates
Entrust client and non-Entrust server (and vice versa)
Both client and server use Entrust certificates
Tutorial: Using SSL
Overview of the security tutorial
Tutorial requirements
Setting up your browser
Start the server, EAServer Manager, and connect to the Certificates folder
Obtain and install a personal certificate
Setting up EAServer
Creating and assigning a security profile to a listener
Assign a security profile to a listener
Running the SSL sample applet
Debugging the SSL sample applet
Feature Guide
About this book
Introducing EAServer
Overview
EAServer execution engine
Component support
J2EE platform support
Network protocol support
Dynamic HTML support
PowerDynamo Web site conversion utility
Web server redirector plug-in
Administration and development tools
Client-session and component-lifecycle management
Naming services
Connection caching
Transaction management
Localization
Result-set support
Support for asynchronous messaging
Asynchronous processing support
Systems management support
Support for legacy Open Server applications
IPV6 support
Developing an EAServer Application
Introductory concepts
Developing an EAServer application
EAServer runtime environment
EAServer Components
Overview
Enterprise JavaBeans components
EJB component types
Stateful session beans
Stateless session beans
Entity beans
EJB transaction attribute values
EJB container services
Java components
CORBA-C++ components
PowerBuilder components
ActiveX components
C components
Web Applications
What is a Web application?
Contents of a Web application
Servlet files
JSP files and tag libraries
Static files
Java classes
Deployment descriptor
Using PowerDynamo with EAServer
EAServer and PowerDynamo architecture
Calling EAServer components from PowerDynamo scripts
Using MASP verses ActiveX and Java
Setting up PowerDynamo as a client
Using Message Bridge for Java with EAServer
Message Bridge overview
Using Message Bridge
Message Bridge and EAServer architecture
For more information
Web Services Toolkit User’s Guide
About this book
Overview of Web Services in EAServer
Web services background and standards
SOAP 1.1
WSDL 1.1
JAX-RPC 1.0
SAAJ 1.1
JAXP 1.1
UDDI 2.0
EAServer Web Services architecture
Installing Web services
Defining, deploying, and exposing Web services using WST
Service styles
Retrieving the Web service’s WSDL
Using Sybase Web Services Toolkit—an Eclipse plug-in
Starting and stopping Eclipse
Web services plug-in
Connecting to servers
Organization
Menu layout and navigation
Accessibility features
Components, Datatypes, and Type Mappings
Supported component types
Supported datatypes
Additional datatype support
Client-side generation of holder classes
Custom datatypes and mappings
Creating custom type mappings
Creating serializers and deserializers
Deployment
Exporting
Web Services Administration
Introduction
Web services server administration
Web services collection administration
Web service administration
Creating Web services from files
Web service projects
Web service management
Creating and managing Web service clients
Web service operation management
Type mappings
Handlers
Defining handlers
Security
Roles and security realms
Web services security tutorial
Managing security realms and roles
Managing roles
Establishing Web service access
XML-Security
Configuring EAServer and enabling XML-Security
Exposing and deploying components as Web services
Exposing Components as Web services
Using the quickly expose wizard
Deploying Components as Web services
Using the quickly deploy wizard
Generating WSDL
UDDI administration
Other components
Web Console—Web Services
Introduction
Logging in to the Web console versus logging into Sybase Central
Web console security and access
Adding an authentication service to EAServer
Disabling JavaScript
Browser support
Authentication time-out in EAServer
Session time-out in EAServer
Plug-in, domain, display, and server administration
Web service collection administration
Web service administration
Web service operation management
Web service parameter management
UDDI administration
Type mappings
Handlers
Managing security realms and roles
Roles
Runtime monitoring
Non-Web service components
Web Console—Registry Services
Introduction
Using the Web console
Navigating the console and managing resources
UDDI administration
UDDI registry profile administration
Searching and publishing to UDDI registries
Inquiries and searches
Searching UDDI registries
Publishing
Businesses
Services
tModels
Additional registry information for published businesses, tModels, and services
The Private UDDI Server
Introduction
Installing and starting the private UDDI server
Starting and connecting to the private UDDI registry
Starting the default UDDI registry
Configuring other private UDDI registries
Connecting to the private UDDI registry
Managing the private UDDI
Administering the private UDDI
Controlling access to resources
Using wstool, wstkeytool, wstant, and wstkeytoolant
Introduction
Working with wstool and wstkeytool
wstool and wstkeytool syntax
Entity identifiers
Working with wstant and wstkeytoolant
Setting up your environment
wstant and wstkeytoolant scripts
wstant and wstkeytoolant syntax
wstant sample files
wstool commands
UDDI administration commands
inquiry
publish
unpublish
Server management commands
list
refresh
restart
shutdown
Web service administration commands
activate
allowMethods
deactivate
delete (1)
delete (2)
deploy (1)
deploy (2)
deploy (3)
disallowMethods
export
exposeComponent
getTMjar
isActive
isAllowed
isStatsEnabled
refresh
resetStats
set_props
startStats
stopStats
upgrade
wsdl2Java
java2Wsdl
Security commands
add
remove
wstkeytool commands
changePin
deleteCert
export
genCertReq
GetCACerts
GetOtherCerts
GetUserCerts
import
printCert
Developing Web Service Clients
Introduction
Stub-based model client
stub-based example
Dynamic proxy client
Dynamic proxy client example
Dynamic invocation interface client
DII client example
Document style client
Document style example
Using the Web Services Toolkit Samples
Samples in WST
Samples on the Sybase Web site
Sample and tutorial location
Creating the sample projects and installing the samples
Using the WST development tool and features
Exposing a Java class as a Web service
Running the test client using HTTPS
Exposing a Web service that implements JAX-RPC defined interfaces
Exposing a stateless EJB as a Web service
Establishing Web service security, and generating a test client
Exposing a CORBA component as a Web service
Google search API demonstration
Developing client applications
Running a dynamic client
.NET sample
PowerBuilder 9 sample
Migrating 4.x Web Services
Introduction
Server-side migration
Client-side migration
Message Bridge for Java™ User’s Guide
About this book
Introduction to Sybase Message Bridge for Java™
Why use Message Bridge
The problem
Java and XML capabilities
XML parser strengths and limitations
The solution
What is Message Bridge?
Message Bridge features
How does Message Bridge work?
Understanding the DataBean Framework
Binding framework
DataBean object graph
DataBean method summary
Names and identifiers
An example
Recipe DTD schema
Schema to class mappings
Using the generated DataBeans
Constructing instances of classes from an XML document
Getting the IngredientList from the Recipe
Using getAttribute to get the number of servings
Getting the ingredient elements from the IngredientList
Constructing a new instance of Recipe from scratch (a new Recipe XML document)
Setting the food and quantity of an Ingredient in a Recipe
Creating an XML document from instances of Recipe class
Using DataBeanOpaque to get DTD name prior to choosing binding classes
Using the Message Bridge GUI
Schema groups
Adding a new schema group
Changing the name of a schema group
Message definitions
Adding a message definition for a DTD
Adding a message definition for an XML Schema
Defining namespaces in message definitions that use DTDs
Modifying an element name
Creating views
Code generation
Using Views
The purpose of views
An example of using a view
Locating the Java documentation
Advanced Topics
DataBeanOpaque
Deserialization
Serialization
Validation
Directory structure of generated code
Runtime location of schemas for validation
Using Message Bridge Samples
Sample descriptions and locations
Sample directory content
Running a sample
Understanding the output
Supported Elements and Declarations for Schemas
Troubleshooting Guide
About this book
Monitoring Techniques
Overview
Gathering information
Logging
EAServer log
Integrating with other logging systems
Server diagnostics
HTTP logs
IIOP log
Installation log
Other useful data
Using stack traces
Obtaining stack traces
EAServer traces
Java exception traces
Tracing network problems
TCP/IP
IIOP
HTTP
TDS
Common Problem Areas
Installation issues
Server crashes, hangs, or disappears
Server crashes
Server crashes on start-up
Server fails at a specific point that is reproducible
Server crashes intermittently
Server hangs
Server disappears
Server slows or runs out of memory
Server starts in Admin mode
Connection problems
Application issues
Generic issues
Java component issues
C++ component issues
PowerBuilder component issues
Avoiding memory leaks
Other design issues
Web server redirector plug-in issues
All Web server redirectors
Microsoft IIS Web server redirector plug-in
Configuration issues
Verifying your configuration
Running EAServer as a service
System-level issues
Operating system issues
CPU sizing
Multiprocessors
UNIX file descriptors
Windows virtual bytes
Performance Issues
Resources
Exception Handling
Overview
Error handling in CORBA Java components
Handling exceptions in CORBA Java clients
CORBA system exceptions in Java
User-defined exceptions in Java
Error handling in CORBA C++ components
CORBA system exceptions in C++
User-defined exceptions in C++
Error handling in ActiveX components
Handling exceptions in ActiveX clients
Using an ActiveX error handler
Structure of an ActiveX exception
Using error pages
Server-level error pages
Error pages for Web applications
Adding an error page
Error pages for JavaServer Pages
Uncaught exceptions
Saving Java source code
JSPs as error pages
PowerBuilder error handling
Unhandled PowerBuilder exceptions
Common Error Messages
Introduction
Error messages
System exceptions
Advanced Topics
Operational management tools
Memory management tools
Evaluating Windows memory
PowerBuilder memory tuning
Runtime monitoring tools
EAServer Manager
EAServer monitoring APIs
jagtool
ListDLLs
Process Explorer
Profiling tools
ps, pstat, pmon, and PsList
SQL tracing
Debuggers
Java debugging tools
Windows debugging tools
UNIX debugging tools
Attaching a debugger to EAServer
Stack traces, dump files, and core files
Windows dump files
UNIX core files
Class loader configuration issues
Common problems with custom class lists
Custom class loader tracing
JAR file locking and copying
Troubleshooting Web services
Check logs and error messages
Verify WSDL files and SOAP addresses
Invoke operations and create a test client
View incoming and outgoing SOAP messages
PowerBuilder Web service considerations
Debugging C++ pseudocomponents
EAServer plug-in for JBuilder
JBuilder JSPs that use connection caches to retrieve ResultSets
WINS and server response time
Windows XP and Service Pack 2
Cisco VPN clients
Personal firewalls and router ACLs
Miscellaneous topics
Additional tools and utilities
Internet Explorer security patch
Drivers that use the DataSource interface
Systems Management Web console
Alert Management System and the message service
Duplicate server names in EAServer Manager
EAServer 5.2.1
EAServer 5.2
EAServer 5.0.1
EDI Products 5.2.2
Enterprise Connect Data Access 15.7
Enterprise Connect Data Access 15.0.1
Enterprise Connect Data Access 15.0
Enterprise Connect Data Access 12.6.1
Enterprise Connect Data Access 12.6
Financial Fusion GlobalFIX 6.0
InfoMaker 12.5.2
InfoMaker 12.5
SAP jConnect for JDBC 16.0
jConnect for JDBC 7.07 SP110
jConnect for JDBC 7.07 SP100
jConnect for JDBC 7.07
jConnect for JDBC 7.0
jConnect for JDBC 6.05
jConnect for JDBC 5.5
M-Business Anywhere 7.0
M-Business Anywhere 6.7
Mainframe Connect 15.0
Mainframe Connect 12.6.1
Mainframe Connect 12.6
SAP Open Server 16.0
SAP Open Server 15.7 SP127
Open Server 15.7 SP121
Open Server 15.7 SP110
Open Server 15.7 SP100
Open Server 15.7
Open Server 15.5
Open Server 15.0, Open Client 15.0, and SDK 15.0
Open Server 12.5.1
Open Server 12.5.1 (Chinese-Simplified)
Open Server 12.5.1 (French)
OpenSwitch 15.1
SAP Sybase PowerAMC 16.5 SP03
SAP Sybase PowerAMC 16.5 SP02
PowerAMC 16.5
PowerAMC 16.1
PowerAMC 16.0
PowerBuilder 12.5.2
PowerBuilder 12.5.1
PowerBuilder 12.5
PowerBuilder Application Server Plug-in 1.1
PowerBuilder Application Server Plugin 1.0
SAP Sybase PowerDesigner 16.5 SP03
SAP Sybase PowerDesigner 16.5 SP02
PowerDesigner 16.5
PowerDesigner 16.1
PowerDesigner 16.0
Real-Time Data Services 4.5
Real Time Data Services 4.0
Real Time Data Services 3.5
Replication Agent 15.0
Replication Agent for DB2 UDB 15.0
SAP Replication Server 15.7.1 SP203
SAP Replication Server 15.7.1 SP202
SAP Replication Server 15.7.1 SP201
SAP Replication Server 15.7.1 SP200
SAP Replication Server 15.7.1 SP200 (Japanese)
SAP Replication Server 15.7.1 SP200 (Simplified Chinese)
Replication Server 15.7.1 SP110
Replication Server 15.7.1 SP100
Replication Server 15.7.1
Replication Server 15.7.1 (Japanese)
Replication Server 15.7.1 (Simplified Chinese)
Replication Server 15.7
Replication Server 15.6
Replication Server 15.5
Replication Server 15.2
Replication Server 15.1
Replication Server 15.0.1
Replication Server 15.0
SAP Replication Server Data Assurance Option 15.7.1 SP202
SAP Replication Server Data Assurance Option 15.7.1 SP200
Replication Server Data Assurance Option 15.7.1 SP110
Replication Server Data Assurance Option 15.7.1 SP100
Replication Server Data Assurance Option 15.7.1
Replication Server - Data Assurance Option 15.7.1 (Japanese)
Replication Server - Data Assurance Option 15.7.1 (Simplified Chinese)
Replication Server Data Assurance Option 15.7
SAP Replication Server, heterogeneous edition 15.7.1 SP200
Replication Server Heterogeneous Edition 15.7.1 SP100
Replication Server Heterogenous Edition 15.7.1
Replication Server Heterogenous Edition 15.7.1 (Japanese)
Replication Server Heterogenous Edition 15.7.1 (Simplified Chinese)
Replication Server Heterogenous Edition 15.6
Replication Server Heterogeneous Edition 15.2
Replication Server Messaging Edition 15.7.1 [SP100]
Replication Server Messaging Edition 15.7.1
Replication Server Messaging Edition 15.2
Replication Server Option for Oracle 15.7.1 ESD #2
SAP Replication Server Options 15.7.1 SP201
SAP Replication Server Options 15.7.1 SP200
Replication Server Options 15.7.1 SP120
Replication Server Options 15.7.1 SP100
Replication Server Options 15.7.1
Replication Server Options 15.7.1 (Japanese)
Replication Server Options 15.7.1 (Simplified Chinese)
Replication Server Options 15.6
Replication Server Options 15.5
Replication Server Options 15.2
Replication Server Options 15.1
Replication Server Options 15.0
Replication Server Real-Time Loading Edition 15.7.1 ESD #2
SAP Mobile Platform SDK 3.0 SP02
SAP Mobile Platform Server 3.0 SP02
SAP Mobile Platform SDK 3.0 and SP01
SAP Mobile Platform 2.3 SP04
SAP Mobile Platform 2.3 SP03
SAP Mobile Platform 2.3 SP02
SAP Mobile Platform 2.3
SAP Sybase RAP 5.0
SDK for SAP ASE 16.0
Software Developers Kit 15.7 SP127
Software Developer's Kit 15.7 SP121
Software Developer's Kit 15.7 SP110
Software Developer's Kit 15.7 SP100
Software Developer's Kit 15.7
Software Developer's Kit 15.5
Software Developer Kit 15.0
Software Developer Kit 12.5.1
SQL Anywhere 12.0.1
SQL Anywhere 12.0.0
SQL Anywhere 11.0.1
SQL Anywhere 11.0.0
SQL Anywhere 10.0.1
SQL Anywhere 10.0
Sybase Aleri Streaming Platform 3.1
Sybase Aleri Streaming Platform 3.2
Sybase Brand Mobiliser 1.3
Sybase Brand Mobiliser 1.2
Sybase Brand Mobiliser 1.1
Sybase CEP Option R4
SAP Control Center 3.3
Sybase Control Center 3.2.8 ESD2
Sybase Control Center 3.2.8 ESD1
Sybase Control Center 3.2.8
Sybase Control Center 3.2.7
Sybase Control Center 3.2.6
Sybase Control Center 3.2.5
Sybase Control Center 3.2.4
Sybase Control Center 3.2.3
Sybase Control Center 3.2.1
Sybase Control Center 3.2
Sybase Control Center 3.1.1
Sybase Control Center 3.1
Sybase Control Center 3.0.1
Sybase Control Center 3.0
Sybase ETL 4.9
Sybase ETL 4.9 (Simplified Chinese)
Sybase ETL 4.9 (Japanese)
Sybase ETL 4.8
Sybase ETL 4.8 - Simplified Chinese
Sybase ETL 4.8 - Japanese
SAP Sybase Event Stream Processor 5.1 SP04
SAP Sybase Event Stream Processor 5.1 SP03
SAP Sybase Event Stream Processor 5.1 SP02
Sybase Event Stream Processor 5.1 SP01
Sybase Event Stream Processor 5.1
Sybase Event Stream Processor 5.0
Sybase Event Stream Processor 5.0 (Japanese)
SAP Sybase IQ 16.0 SP04
SAP Sybase IQ 16.0 SP03
SAP Sybase IQ 16.0 SP03 (Japanese)
SAP Sybase IQ 16.0 SP03 (Simplified Chinese)
SAP Sybase IQ 16.0 SP2
SAP Sybase IQ 16.0 SP01
SAP Sybase IQ 16.0
Sybase IQ 15.4
Sybase IQ 15.4 (Japanese)
Sybase IQ 15.4 (Simplified Chinese)
Sybase IQ 15.3
Sybase IQ InfoPrimer 15.3
Sybase IQ 15.3 (Japanese)
Sybase IQ 15.3 (Simplified Chinese)
Sybase IQ 15.2
Sybase IQ 15.2 - (Japanese)
Sybase IQ 15.2 (Simplified Chinese)
Sybase IQ 15.1
Sybase IQ 15.1 (Japanese)
Sybase IQ 15.1 - Simplified Chinese
Sybase IQ 15.0
Sybase mBanking 365 3.0
Sybase mBanking 365 2.1
Sybase mBanking 365 2.0
Sybase Mobile Sales for SAP CRM 1.2.1
Sybase Mobile Sales for SAP CRM 1.2
Sybase Mobile Sales for SAP CRM 1.1
Sybase Mobile Sales for SAP CRM 1.0
Sybase Mobile Workflow for SAP Business Suite 1.2.1
Sybase Mobile Workflow for SAP Business Suite 1.2
Sybase Mobile Workflow for SAP Business Suite 1.1
Sybase Mobiliser Platform 5.1 SP03
Sybase Mobiliser Platform 5.1
Sybase Mobiliser Platform 5.0
Sybase SAP DOE Connector 2.1
Sybase SAP DOE Connector 2.0
Sybase Search 3.1
Sybase Unwired Platform 2.2 SP05
Sybase Unwired Platform 2.2 SP04
Sybase Unwired Platform 2.2 SP03
Sybase Unwired Platform 2.2
Sybase Unwired Platform 2.1 ESD #3
Sybase Unwired Platform 2.1 ESD #2
Sybase Unwired Platform 2.1 ESD #1
Sybase Unwired Platform 2.1
Sybase Unwired Platform 2.0 ESD #1
Sybase Unwired Platform 2.0
Sybase Unwired Platform 1.5.5
Sybase Unwired Platform 1.5.3
Sybase Unwired Platform 1.5.2
Sybase Unwired Platform 1.2.4
Sybase Unwired Platform 1.2.2
Sybase Unwired Platform 1.2.1
Sybase Unwired Platform 1.2
Sybase WorkSpace 2.5
Sybase WorkSpace 2.1.2
Sybase WorkSpace 2.1
Sybase WorkSpace 2.0.2
SyBooks 3.4
SyBooks 3.0.1
SySAM Documentation
SySAM Documentation - Japanese
SySAM Documentation - Simplified Chinese
SyBooks Online Infocenter Help