SOA Concepts
Important Information
TIBCO Documentation and Support Services
Introduction
Challenges of Service Delivery
Design
Design Activities
Runtime
Runtime Overview
Hosts
Nodes
Features
Resource Templates
Resource Instances
Administration
Overview of ActiveMatrix Administrator
TIBCO ActiveMatrix
Enterprise
Environments
Messaging Bus
Governance
Service Registry
Identity Management
Monitoring Service
Policy Management
Service Component Architecture
Composites
Components
Component Implementation
Services and References
Interfaces
Bindings
Properties
Message Exchange Patterns
Java Components
Composite Components
Mediation Components
WebApp Components
Spring Components
SOA Development Tutorials
Important Information
TIBCO Documentation and Support Services
Basic SOA Design Tutorials
Java Tutorials
Mediation Tutorials
WebApp Tutorials
Policy Tutorials
Configuring the ResourceInstance Attribute in an External Policy
Preparing an Application that Injects Resource Instances into Policies
Composite Development
Important Information
TIBCO Documentation and Support Services
TIBCO Business Studio
TIBCO Business Studio Configuration
Target Platforms
Displaying the Target Platform
Creating a Target Platform File
Setting the Target Platform
Platform Installation
Setting the Platform Installation
Platform Installation Reference
Starting TIBCO Business Studio
SOA Projects
Special Folders
Enabling and Disabling Special Folders
Versions
WSDL Files
Renaming a Port Type
Validation
Validating WSDL and Schema Files Referenced by a Composite
Disabling Validation
Resolving Validation Rule Violations
Creating an Empty SOA Project
Creating a Basic SOA Project
Creating a SOA Project from WSDL Files
Creating an SOA Project from an Implementation
Legacy Projects
Migrating Legacy Projects
Migration Reference
Composites
Creating a Composite
Setting Composite Diagram Preferences
Adding an Element to a Composite
Popup Toolbars
Palette
Application Modularization
Running and Debugging a Composite
Creating a Run Configuration
Running a Composite
Run Configuration Reference
Creating a Debug Configuration
Debugging a Composite
Setting Breakpoints
Removing Breakpoints
Configuring Breakpoints
Controlling Composite Execution
Debug Configuration Reference
Terminating a Configuration
Composite Reference
Components
Creating a Component
Changing the Implementation Type of a Component
Configuring a Components External Custom Feature
Component Reference
Services and References
Interfaces
Adding a Service or Reference to a Component
Adding a Service or Reference to a Composite
Promoting a Component Service or Reference
Static and Dynamic Wiring
Creating a Static Wire Between a Service and a Reference
Configuring a Reference for Dynamic Wiring
Service Reference
Reference Reference
Bindings
Viewing Service and Reference Bindings
Adding a Binding to a Service or Reference
SOAP Bindings
SOAP Binding Reference
Fault Messages
WS-Addressing
Endpoint References
Message Addressing Properties
Validation and Fault Handling
Configuring the Action Property
Enabling WS-Addressing
Generating a Concrete WSDL File
WSDL Generation Reference
Generating a SOAP Request
WS-Reliable Messaging
Enabling WS-Reliable Messaging
JMS Bindings
JMS Binding Reference
Context Parameters
Creating Context Parameters
Mapping Context Parameters to Header Fields
Context Parameter Reference
Enabling Transactions in SOAP and JMS Bindings
Policy Management
Policies
Governed Objects
Intents
Configuring Intents
Intents Reference
At Least Once Intents
At Most Once Intents
Authorization Intents
Client Authentication Intents
Consumer Confidentiality Intents
Consumer Integrity Intents
Credential Mapping Intents
Managed Transaction Intents
Prepare Before Undeploy Intents
Provider Confidentiality Intents
Provider Integrity Intents
Secure Virtualization Intents
Start Services First Intents
Transacted OneWay Intents
Policy Sets
Displaying the Policy Sets Picker
Configuring Policy Sets
Editing Embedded Policy Sets
Creating an External Policy Set
Configuring External Policy Sets with XML
Embedded Policy Sets Reference
JMS At Most Once
JMS At Least Once
JMS Transacted OneWay
Managed Transaction
Message Transmission Optimization Mechanism (MTOM)
Prepare Before Undeploy
Secure Virtualization
Start Service First
Threading
Virtualization At Least Once
Virtualization Transacted OneWay
Virtualize
Never Virtualize
WS-Addressing for References
WS-Addressing for Services
WS-Reliable Messaging
Policy Templates Reference
Policy Template to Intents Reference
Authorization By Role Policies
Basic Authentication Policies
Basic Credential Mapping Policies
Basic Or Username Token Authentication Policies
SAML Authentication For SSO Policies
SAML Credential Mapping For SSO Policies
Username Token Authentication Policies
WS-Security Consumer Policies
WS-Security Provider Policies
Transactions
Managed Global Transactions
Transacted OneWay Transactions
Non-Managed Transactions
Resource Templates
Resource Instances
Creating a Resource Template
Opening a Resource Template
Finding References to a Resource Template
Renaming a Resource Template
Resource Templates Reference
Resource Templates With Scope
Changing the Scope of a Resource Template
Modifying Resource Templates to Install Multiple BPM Environments
Application Deployment Patterns
Hibernate
HTTP Client
JDBC
Configuring Third-Party JDBC Drivers
JMS Resource Templates
Configuring Third-Party JMS Drivers
JMS Connection Factory
JMS Destination
JNDI Connection Configuration
JMS Destination Configuration
LDAP Connection
Security Resource Templates
Identity Provider
Kerberos Identity Provider
Keystore Provider
Keystores
Creating a Keystore With a Username and Password
SSL Client Provider
SMTP
Thread Pool
Teneo
Properties
Creating a Property
Promoting a Component Property
Setting the Value of a Binding Property
Setting the Value of a Composite Property
Setting the Value of a Component Property
Setting the Value of a Resource Template Property
Creating an Obfuscated Password
Properties Reference
Substitution Variables
Creating a Substitution Variable
Creating a Substitution Variable File
Finding References to a Substitution Variable
Renaming a Substitution Variable
Custom Features
Creating a Custom Feature
Finding References to a Custom Feature
Renaming a Custom Feature
Configuring Plug-ins
Configuring Feature Dependencies
Configuring Excluded Custom Feature Dependencies
Custom Feature Reference
Shared Libraries
Bundles and Plug-in Projects
Creating a Library Plug-in Project
Distributed Application Archives
Packaging a Composite in a DAA
Packaging a Custom Feature in a DAA
Regenerating a Distributed Application Archive Containing a Composite
Generating and Verifying Derived DAAs
Distributed Application Archive Specifications
Qualifier Replacement
Distributions
Creating a Distribution
Editing a Distribution
Creating a Distribution Template
Applications
Creating Deploying and Starting an Application
Stopping Undeploying and Deleting an Application
Debugging Deployed Applications
Checking Remote Debugger Status
Creating a Debug Configuration
Launching a Debug Configuration
Attaching a Debugger to a Running Application
TIBCO ActiveMatrix Administrator
Deployment Servers
Creating a Deployment Server
Connecting to a Deployment Server
Editing Deployment Server Properties
Refreshing a Deployment Server
Disconnecting from a Deployment Server
Deployment Server Reference
Administrator Explorer View
Displaying the Administrator Explorer View
Administrator Command-Line Interface
Understanding Build Files
Understanding AMXAdminTask
Actions Performed Using CLI
Understanding Data Files
Undertstanding Objects
Object Formats
Property File Reference
Generating an Administrator Command-Line Interface Script
Script Configuration
Administrator Connection Configuration
Application Configuration
Distribution
Property Configuration
Wiring Configuration
Running Administrator Command-Line Interface Scripts
TIBCO Business Studio Command-Line Interface
Running a TIBCO Business Studio Command-Line Interface Script
TIBCO Business Studio Command-Line Reference
TIBCO Business Studio Command-Line Task Reference
Logging
Application Logging
Message Flow Logging
Logging Payload Reference
IPv6 Support
Java Component Development
Important Information
TIBCO Documentation and Support Services
Java Components
Creating a Java Component
Configuring a Java Components Implementation
Updating a Java Component
Configuring a Java Components Custom Feature
Upgrading a Java Component
Component Feature Dependencies
Java Component Reference
Java Component Implementations
Data Binding
Generating XML Data Binding Classes
Data Binding Classes for Abstract and Concrete WSDL Files
XML Data Binding Reference
Opening a Java Component Implementation
Generating a Java Component Implementation
Generate Java Component Implementation Reference
Regenerating a Java Component Implementation
Upgrading a Java Component Implementation
Life Cycle Events
Component Context
Accessing a Property
Accessing a Resource
Accessing a Hibernate Resource
Accessing a JDBC Resource
Accessing JMS Resources
Accessing LDAP Connections
Accessing SMTP Connections
Accessing a Teneo Resource
Invoking an HTTP Request
Invoking a Reference Operation
Error Handling
SOAPException Reference
Context Parameters
Working with Context Parameters
Endpoint References
Retrieving an Endpoint Reference
Creating an Endpoint Reference
Custom Features
Bundles and Plug-in Projects
Configuring Dependencies on External Java Classes
Versions
Java API Reference
Converting Migrated Java Component Implementations
Creating an Abstract Class
Editing a Manifest
Regenerating a Component Implementation
Removing 2.x Data Binding JAR Files
Correcting Custom Feature File
Default XML to Java Mapping
Mediation Component Development
Important Information
TIBCO Documentation and Support Services
Introduction to Mediation
Mediation Flows
Message Exchange Patterns
Mediation Flow Interfaces
Planning Target and Mediation Interfaces
Paths in a Mediation Flow
Mediation Tasks
Mediation Exchange
Designing Mediation Flows
Working with Mediation Flows
Starting the Mediation Flow Wizard
Creating a New, Empty Mediation Flow
Creating New Mediation Flows from Existing Web Services
Editing Mediation Flow Editor Preferences
Working with Mediation Flow Properties
Validation of Message
Adding a Mediation Flow Property
Deleting a Mediation Flow Property
Working with Interfaces
Adding Interfaces to Mediation Flows
Deleting Interfaces from Mediation Flows
Moving Mediation Interfaces
Using the AutoMediate Feature
Creating Local WSDL Files
Supported Policies
Working with Mediation Paths
Changing Mediation Paths
Deleting Mediation Paths
Working with Message Context Properties
Context Parameters
Mediation Context Parameters
Undeclared Fault Headers
Context Parameters in Mediation Components
Adding Context Parameters
Deleting Context Parameters
Defining the Scope of Context Parameters
Working with Exchange Variables
Defining Exchange Variables
Setting Exchange Variable
Creating Simple Schemas
Working with Tasks
Adding a Task to a Path
Deleting a Task From a Path
Mediation Components
Invoking an Operation
Configuring Invoke Operation Tasks
Logging Mediation Exchange Information
Mediation Appenders and Loggers
Configuring a Log Task
Routing Messages in a Mediation Flow
Paths and Route Tasks
Defining a Route
Adding Routing Cases
Specifying Case Targets in the Decision Table
Modifying Case Names
Modifying Destinations
Moving Cases in the List
Deleting Cases
Nesting Multiple Route Tasks
Adding and Deleting Variables
Mapping Data to Variables
Routing Conditions
Editing Route Task Conditions
Conditions for XPath Route Tasks
Changing Route Tasks to XPath Route Tasks
Transforming Tasks
Example of Transformation
Basic Mapping
Using XPath Editor
Data Contribution to the Mediation Exchange
External Stylesheets for Data Transformation
Specifying an External Stylesheet for Data Transformation
Schema Components
Context Panel
Message Panel
Data and Function Tabs
TIBCO XPath Functions
Creating Custom XPath Functions
Exporting Custom XPath Functions
Deploying Custom XPath Functions
Testing Custom XPath Functions
Mapper Toolbar Buttons
Right-Click Menu in the Message Panel
Surrounding a Component With a Choose Statement
If Statements
For Each Statements
Adding a Variable to a Mapping
Managing Mappings
Repairing Incorrect Mappings
Mapping an Empty Complex Type
Using XPath
Transforming XML with Related Tasks
Querying a Database
JDBC Resource Templates
Defining a Resource Template
Configuring a JDBC Driver
Registering a JDBC Driver
Configuration Tabs of the Query Database Task
Dynamic Requests
Service Providers for Dynamic Composite References
Configuring Dynamic Binding
Configuring Dynamic Target Interfaces
Pattern Variables Usage
Dynamic Reference Task Setting
General Tab Configuration
Input Specification
Configuring Dynamic References in Composite
Creating and Deploying Composites Used By Dynamic Binding
Replying to Messages
Fault Processing in a Mediation Flow
Throwing Faults in Mediation Flows
Fault Paths
Catch Fault Configuration
Catching Faults from the Mediation Flow
Sending Faults to the Invoker
Custom Mediation Tasks
Migrating Custom Mediation Tasks
Eclipse Plug-in Reference
Support Files
Creating the Model Plug-in
Creating the UI Plug-in
Creating the Runtime Plug-in
Writing Custom Mediation Code
Accessing Task Input/Output Schema
Modifying the Mediation Task Data
Defining Model Attributes
Custom Mediation Task Categories
Thrown Faults
Runtime Exceptions
Installing Custom Mediation Tasks
Deploying Custom Mediation Tasks
Testing Custom Mediation Tasks
Reference
Catch Fault
End Mediation
Generate Reply
Handle Reply
Invoke Operation
Log
Information for Standard Log Messages
Information for Custom Log Messages
Parse XML
Query Database
Render XML
Route Task
Send Fault
Set Context
Set Dynamic Reference
Set Exchange Variable
Throw Fault
Transform
Validate XML
XPath Route
TIBCO AutoMediate Command-Line Tool
AutoMediate Command-Line Tool Flow
Running the AutoMediate Command-Line Tool
AutoMediate Command Syntax and Options
AutoMediate ANT Command Syntax and Options
Introduction to gXML Applications
Developing gXML Applications
Implementing GxApplication
Implementing GxCatalog
Implementing GxResolver
Injecting DOM
gXML Recipes
Parsing a Character Stream and a Byte Stream
Constructing a Data Model Tree Programmatically
Validating
Navigation
Mutation
Serialization
XPath
XSLT
XQuery
Validation
Mediation API Reference
Important Information
TIBCO Documentation and Support Services
API Reference Pages
Web Application Component Development
Important Information
TIBCO Documentation and Support Services
Overview
Introduction
Approaches
Web Application Components
Creating a WebApp Component
Creating an SOA Project
Adding an Empty WebApp Component
Starting With an Existing Implementation
OSGi-enabled WebApp Component
Creating an OSGi-enabled WebApp Component
Configuring a Web Application Component
Configuring a WebApp Components Custom Feature
Configuring a WebApp Components External Custom Feature
WebApp Component Reference
Adding Configuring a WebApp Components Security
Using Form-based Authentication Policy
Adding Configuring Form-based Authentication Policy
Security Constraint Policy
Security Constraint Definition Example
Adding Configuring A Security Constraint Policy
Updating a WebApp Component
ZeroConfiguration DAA Creation Using WAR
Limitations on WAR Files
Web Application Component Implementations
Opening an Implementation
Generating an Implementation
Generate WebApp Component Implementation
Code Generation Details Dialog
XML Data Binding Classes Dialog
Create Servlet Dialog
Regenerating an Implementation
Refreshing an Implementation
Accessing a Property
Invoking a Reference Operation
WebApp Component Testing
RAD Communication
JAD Communication
Logging
Handling Errors
URL Mappings
Use of URL Paths
Specification of Mappings
Implicit Mappings
SOA Administration Tutorials
Important Information
TIBCO Documentation and Support Services
Overview
Tutorial Prerequisites
Set Up the Runtime Environment
Create a UDDI Server in Administrator
Configure Administrator Command-Line Properties
Set Up the Service Invocation Environment
How to Configure Logging
Creating a Logging Appender
Navigating to a Logging Configurations List
Creating a Logging Configuration for a Host or a Node
Applying a Logging Configuration
How to Deploy and Run the Hello World Application
Completing Hello World Prerequisites
Creating the Hello World Application
Creating an HTTP Connector Resource Template
Creating and Installing the HTTP Connector Resource Instance
Distributing the Hello World Application
Deploying and Starting the Hello World Application
Generating the Hello World WSDL File
Invoking the Hello World Service
Viewing the Hello World Service in the UDDI Registry Server
How to Deploy and Run the Enhanced Hello World Application
Completing Enhanced Hello World Prerequisites
Deploying and Starting the Date Manager Application
Creating the Hello World Application
Creating an HTTP Connector Resource Template
Creating and Installing the HTTP Connector Resource Instance
Creating and Installing the HTTP Client Resource Instance
Distributing the Enhanced Hello World Application
Deploying and Starting the Enhanced Hello World Application
Generating the Hello World WSDL File
Invoking the Hello World Service
How to Deploy and Run the Phonebook Application
Completing Phonebook Prerequisites
Creating the Phonebook Application
Creating an HTTP Connector Resource Template
Creating and Installing the HTTP Connector Resource Instance
Creating and Installing the JDBC Shared Resource Instance
Distributing the Phonebook Application
Deploying and Starting the Phonebook Application
Generating the Phonebook WSDL File
Invoking the Phonebook Service
How to Deploy and Run the Hello World Web Application
Completing Hello World Web Application Prerequisites
Creating the Hello World Web Application
Creating an HTTP Connector Resource Template
Creating and Installing the HTTP Connector Resource Instance
Distributing the Hello World Web Application
Deploying and Starting the Hello World Web Application
Invoking the Hello World Web Application
How to Deploy and Run the Content-Based Routing Mediation Application
Creating the Routing and Target Service Mediation Applications
Creating HTTP Connector Resource Templates
Creating and Installing Resource Instances
Distributing the Routing and Target Service Applications
Deploying and Starting the Routing and Target Service Applications
Generating the Routing WSDL File
SOA Administration
Important Information
TIBCO Documentation and Support Services
Introduction to Administrator
Components and Servers
Using the Web Interface
Logging in to the Web Interface
Understanding Administrator Object States
Runtime State
Runtime States
Action History
Action History Reference
Outstanding Actions
Synchronization
Using Command-Line Interface
Location of Sample Files
Invoking the Command-Line Interface
Understanding Build Files
Understanding AMXAdminTask
Understanding Data Files
Actions Performed Using CLI
Undertstanding Objects
Supported Objects
Object Formats
Object Navigation
Inter-Object Relationships
Property File Reference
Managing the Administrator Server
Administration Support for Older Hosts and Nodes
Administrator Configuration Reference
Default Ports Used by Servers
Plug-Ins
Plug-Ins Reference
Notification Server
Editing the Notification Server Configuration
Forcing a Reconnection
Authentication Realms
Administrator Replication
Creating an Environment
Configuring an Environments Messaging Bus
Environment General Reference
Environment Configuration Reference
Messaging Bus Reference
Using Diagnostics
Accessing and Using Diagnostics Commands
Retrieving Log Files for Hosts and Nodes from Administrator
Managing Hosts
Host Processes
Creating a TIBCO Host Instance
Assigning a Host to An Environment
Starting a TIBCO Host Instance
Stopping a TIBCO Host Instance
Enabling Secure Communication between a Host and an Administrator Server
Unregistering Hosts
Binding Hosts to an Administrator Server
Discover Hosts Reference
Register Host Reference
References
Hosts Reference
Host General Reference
Host Configuration Reference
Host Substitution Variables Reference
Host Resource Instances Reference
Managing Nodes
Node Processes
Developer Node
Navigating to a Nodes List
Creating a Node
Editing a Node
Updating the Port Number for a Node
Updating the JVM Configuration for a Node
Enabling and Disabling the Java Security Manager
Enabling and Disabling Debuggers
Installing or Syncing Nodes
Uninstalling Nodes
Starting Nodes
Manually Restarting Nodes
Stopping Nodes
Deleting Nodes
References
Nodes Reference
Node General Reference
Node Configuration Reference
Node Substitution Variables Reference
Node Resource Instances Reference
Transaction Recovery Configuration
Configuration Properties for HOWL Log Files
Deleting HOWL Logs
Managing Applications
Creating an Application
Distribution Modes
Distributing an Application
Application Dependencies
Deploying Applications
Undeploying Applications
Starting Applications
Stopping Applications
Deleting Applications
Editing an Application
Upgrading an Application
Applications Reference
Displaying an Applications Dependencies
Displaying an Applications Components
Displaying an Applications Bindings
Application General Reference
Application Configuration Reference
Application Substitution Variables Reference
Application Distribution Reference
Application Folders
Creating a Folder
Renaming a Folder
Deleting a Folder
Moving an Application to a Folder
Properties
Setting a Property Value
Editable Properties Reference
Non-Editable and Policy Set Properties Reference
Services and References
Displaying the Bindings for a Service or a Reference
Adding a Binding to a Service
Configuring a Binding for a Reference
Promoting a Service to the Environment
Promoting a Reference to the Environment
Reference Details Reference
Manual Binding Reference
Bindings
SOAP Bindings
Starting and Stopping Bindings
Generating a WSDL File for a SOAP Service Binding Instance
SOAP Binding Reference
WS-Addressing
Endpoint References
Message Addressing Properties
Validation and Fault Handling
Configuring the Action Property
WS-Reliable Messaging
JMS Bindings
JMS Binding Reference
Wire to Binding Reference
Managing Resource Templates
Resource Templates With Scope
Creating a Resource Template
Editing a Resource Template
Incremental Editing of a Resource Template
Renaming a Resource Template
Changing the Scope of a Resource Template
Deleting Resource Templates
Creating an Obfuscated Password
Configuring Mutual Authentication
Configuring Third-Party JDBC Drivers
Adding an Updated JDBC Driver
Configuring Third-Party JMS Drivers
Configuring the Read Response Timeout for an LDAP Connection
Keystores
Creating a Keystore Containing a User Name and Password
References
Hibernate
HTTP Client
HTTP Connector
JDBC
JMS Resource Templates
JMS Connection Factory
JMS Connection Factory Configuration
JMS Destination
JMS Destination Configuration
JNDI Connection Configuration
LDAP Connection
SMTP
Teneo
Thread Pool
Security Resource Templates
Identity Provider
Kerberos Authentication
Kerberos Identity Provider
Keystore Provider
Keystores
Creating a Keystore Containing a User Name and Password
LDAP Authentication
Mutual Identity Provider
SiteMinder Authentication
SSL Client Provider
SSL Server Provider
Trust Provider
WSS Authentication
Managing Resource Instances
Creating Resource Instances on Nodes
Installing Resource Instances on Nodes
Uninstalling Resource Instances from Nodes
Deleting Resource Instances from Nodes
Resource Instances Reference
Substitution Variables
Creating a Substitution Variable
How Substitution Variables Are Resolved
Software Management
Adding Features to the Enterprise
Adding a Feature to a Node
Adding Third-Party Libraries to Nodes
Setting Node Features
Removing Features from a Node
Deleting Features from the Enterprise
Adding Application Templates to the Enterprise
Deleting Application Templates
Feature Reference
Features Reference
Application Template Reference
Versions
Distributed Application Archives
Uploading a Distributed Application Archive
Distributed Application Archive Reference
Monitoring
Monitoring Service
Disabling the Monitoring Service
Enabling and Disabling Extended Monitoring
Configuring a Fault Tolerant Monitoring Service
Updating the Messaging Configuration
Metrics Reference
Log Viewer
Running Searches
Search Builder
Filter Area
Adding and Removing Filters
Event Models
Base Event Format Attribute Reference
Engine Event Format Attribute Reference
BW Engine Event Format Attribute Reference
Log Table
Deleting Log Entries
Dashboards
Displaying the Dashboards
Filter Criteria Gadget
Setting Dashboard Preferences
Drilling Down into Objects
Dashboard Controls
Users, Groups, and Permissions
Creating a User
Changing a User Password
Resetting a User Password
Assigning Superuser Privileges
Removing Superuser Privileges
Adding Users to Groups
Removing Users from Groups
Creating a Root Group
Creating a Subgroup
Deleting a Group
Setting Object-Specific Permissions
Setting Enterprise Permissions
Permission Reference
Groups
Superusers
Users
Permissions
System Logging
Log Services
Editing Log Service Properties
Log Service Property Reference
Logging Appenders
Creating a Logging Appender
Logging Appender Reference
Log Entry Enrichment
Logging Configurations
Navigating to a Logging Configurations List
Creating a Logging Configuration for a Host or a Node
Applying a Logging Configuration
Logging Configuration Reference
Payload Services
Payload Service Properties Reference
Creating Additional Log and Payload Services
Secure Communication Channels
Trust Stores
Creating a Trust Store Keystore
Configuring a Trust Store
Enabling Secure Communication Channels Using Command-Line Scripts
Installing Unlimited Jurisdiction Files
TIBCO Credential Service
Network Configuration
IPv6 Support
Port Usage
UDDI Servers
Registering an SSL-Enabled UDDI Server
Registering a UDDI Server
Setting the Default UDDI Server
Configuring SSL Communication
Publishing Services in a UDDI Server
References
UDDI Server Reference
Application UDDI Publication Reference
NodeUtil
Invoking the NodeUtil Utility
NodeUtil Commands
Troubleshooting