• Building DevOps Edition for Continuous Integration
• Document Conventions
• Online Information and Support
• Data Protection
•  Working with Designer
  • About This Guide
  •  Tips for Working with Software AG Designer
    • Managing Designer User Configuration
    • Changing the JRE or JDK Used by Designer
    •  Configuring the Secure Storage
      • Secure Storage Runtime Options
    •  Monitoring and Modifying Memory Usage
      • Adjusting the Designer Memory Settings
    • Verifying Java Byte Code
    • Java Code Cache
    •  Finding Installed Products, Versions, and Fixes
      • Identifying Installed Products, Versions, and Fixes
      • Viewing and Copying Information About Software AG Features
    •  Using Designer with Software AG Runtime
      • Defining a Software AG Runtime Entry in the Servers View
      • Adding the Software AG Runtime Environment
    •  Enabling Designer Console Output on Windows
      • Modifying the Designer Configuration to Enable Console Output
      • Adding Parameters to the Command Line to Enable Designer Console Output
      • Modifying a Designer Shortcut to Enable Console Output
    • Configuring SSL Connections in Designer
    • Enabling Automatic Updates
    • Enabling Eclipse Update Sites
    • Enabling Error Reporting Notifications
    • Enabling Preference Recorder
•  Service Development Help
  • About this Guide
  •  About webMethods Service Development
    • Before You Use Designer for Service Development
    • Opening the Service Development Perspective
  •  Working with webMethods Integration Server
    •  Working with Server Definitions
      • Creating Server Definitions
      • Fetching Server Definitions from an Integration Server
      • Importing Server Definitions
      • Exporting Server Definitions
      • Removing Server Definitions
      • Editing Server Definitions
      •  Considerations for Process Development
        • Setting a Default Server Definition
        • Placing a Server Definition Offline
        • Bringing a Server Definition Online
    •  Connecting to an Integration Server
      • Connecting to an Integration Server through Preferences
    •  Disconnecting from an Integration Server
      • Disconnecting from an Integration Server via Preferences
    • Refreshing an Integration Server
    • Notification of Server Shutdown
    • Opening Integration Server Administrator
    • Viewing Integration Server Properties
    •  Changing Passwords
      • Changing Your Password
      • Synchronizing Passwords
  •  Working with Elements
    •  About Element Names
      • Package Names and Element Names
    •  Creating New Elements
      • Guidelines for Naming Elements
    • Guidelines for Working with Elements
    • Opening Elements
    • Closing Elements
    • Editing and Saving Elements
    • Adding Comments for an Element
    • Configuring Dependency Checking for Elements
    • Controlling the Reuse of Elements Published to CentraSite
    • Allowing Editing of Derived Elements
    •  Moving and Copying Elements
      • Guidelines for Moving and Copying All Types of Elements
      • Guidelines for Moving and Copying Services
      • Guidelines for Copying Elements Between Servers
      • Notes for Moving and Copying Adapter Notifications and Related Elements
    • Renaming Elements
    • Guidelines for Refactoring Elements
    • Refactoring Elements
    • Deleting Elements
    •  Finding Dependents and References
      • What Is a Dependent?
      • Finding Dependents
      • What Is a Reference?
      • Finding References
    •  Inspecting Pipeline References
      • Inspecting Pipeline References
    •  Finding Elements
      • Guidelines for Searching Elements
      • Searching for Elements in Package Navigator
      • Performing a Quick Search of Elements in Package Navigator
      • Locating Invoked Services
      • Locating Referenced Document Types
      • Linking Open Editors
    • Filtering Displayed Elements
    • Hiding or Displaying Automatically Generated Flow Services
    • Creating Working Sets
    •  Caching Elements
      • Clearing the Designer Cache
    • Exporting Elements
    • Viewing Server Files for an Element
    •  Using Property Templates with Elements
      • Creating Property Templates
      • Applying Property Templates to Elements
      • Editing Property Templates
      • Deleting Property Templates
      • Importing Property Templates
      • Exporting Property Templates
  •  Assigning and Managing Permissions for Elements
    •  What Is an ACL?
      • What Happens When a Client Runs a Service with ACLs?
      • Is ACL Usage Required?
      • Creating ACLs
      • ACLs and Inheritance
      • Default ACLs and Inheritance
    • Assigning ACLs
    • Viewing ACL Information for a Server
    • ACLs and Locking
    • ACLs and Running/Debugging Services
    • ACLs and Creating, Viewing, and Deleting Elements
    • Troubleshooting ACL Usage
  •  Locking and Unlocking Elements
    • What Is a Lock?
    •  About Locking Elements
      • Locking Elements in Designer
      • Guidelines for Locking Java and C/C++ Services
      • Guidelines for Locking Templates
      • System Locking Elements
    •  Viewing the Status of Locked Elements
      • Viewing Lock Status of Elements
      • Listing All of Your Locked Elements
    • Copying, Moving, or Deleting Locked Elements
    •  Unlocking Elements
      • Unlocking Elements in Designer
      • Automatically Unlocking an Element Upon Saving
    •  Troubleshooting
      • Lock and Unlock Problems
      • Package Management Problems
      • Save Problems
      • Other Problems
      • Frequently Asked Questions
  •  Using the Local Service Development Feature
    • About the Local Service Development Workflow
    • Supported Platforms and Eclipse Plug-ins
    • Supported Elements
    • Supported and Unsupported Actions
    • Prerequisites
    •  Permissions and Locking
      • Permissions
      • System Locking and Local Service Development
    • Setting the Local Development Server
    • Creating a Local Service Development Project
    • Adding Folders and Elements to the VCS
    • Modifying Packages, Folders, or Elements in the VCS
    • Checking Out an Element from the VCS
    • Checking In Packages and Element to the VCS
    • Getting the Latest Version from the VCS
    • Getting a Specific Version from the VCS
    • Copying Packages from the VCS to Integration Server
    • Reloading a Package
    • Comparing Revisions of an Element
    • Building Java and C Services
    • Deleting a Package Associated with a Local Service Development Project
    • Deleting a Local Service Development Project
  •  Managing Packages
    •  Creating a Package
      • Guidelines for Naming Packages
    •  Documenting a Package
      • Accessing Package Documentation
    • Viewing Package Settings, Version Number, and Patch History
    • Assigning a Version Number to a Package
    •  About Copying Packages Between Servers
      • Copying Packages
    • Reloading a Package
    • Comparing Packages
    • Deleting a Package
    • Exporting a Package
    •  About Package Dependencies
      • Identifying Package Dependencies
      • Removing Package Dependencies
    •  Assigning Startup, Shutdown, and Replication Services to a Package
      •  What Is a Startup Service?
        • Assigning a Startup Service
        • Removing a Startup Service
      •  What Is a Shut Down Service?
        • Assigning a Shutdown Service
        • Removing a Shutdown Service
      •  What Is a Replication Service?
        • Assigning a Replication Service
        • Removing a Replication Service
  •  Building Services
    • A Process Overview
    • Package and Folder Requirements
    •  About the Service Signature
      • Guidelines for Specifying Input Parameters
      • Guidelines for Specifying Output Parameters
      •  Declaring Input and Output Parameters
        • Using a Specification as a Service Signature
        • Using an IS Document Type to Specify Service Input or Output Parameters
        • Inserting Input and Output Parameters
    •  About Service Run-Time Parameters
      •  Maintaining the State of Service
        • Specifying the Run-Time State for a Service
      •  About Service Caching
        • When Are Cached Results Returned?
        • Types of Services to Cache
        • Controlling a Service’s Use of Cache
        • Specifying the Duration of Cached Results
        • Refreshing Service Cache by Using the Prefetch Option
        • Configuring Caching of Service Results
      • Specifying the Execution Locale
      •  About URL Aliases for Services
        • Creating a Path Alias for a Service
      •  Automatically Saving or Restoring the Pipeline at Run Time
        • Configuring Saving or Restoring of the Service Pipeline at Run Time
      • Specifying the Default Format for an XML Document Received by the Service
      • Configuring HTTP Methods Allowed for a Service
    •  About Automatic Service Retry
      • About the Maximum Retry Period
      • Configuring Service Retry
    •  About Service Auditing
      •  Service Auditing Use Cases
        • Error Auditing
        • Service Auditing
        • Auditing for Recovery
        • Auditing Long-Running Services
      • Configuring Service Auditing
      •  Logging Input and Output Fields
        • Selecting Input or Output Fields for Logging
        • Logged Field Data Types in JDBC
      • Assigning a Custom Value to an Auditing Context
    •  Using a Circuit Breaker with a Service
      • Considerations for Configuring a Circuit Breaker for a Service
      • Configuring a Circuit Breaker for a Service
    •  About Universal Names for Services or Document Types
      • Implicit and Explicit Universal Names
      • Assigning, Editing, or Viewing an Explicit Universal Name
      • Deleting an Explicit Universal Name
      •  The Universal Name Registry
        • Services You Use to Interact with the Universal Name Registry
    •  About Service Output Templates
      • Creating an Output Template
      • Assigning an Output Template to a Service
    • Viewing Service Information
  •  Building Flow Services
    •  What Is a Flow Service?
      • What Is a Flow Step?
      • What Is the Pipeline?
    • Building Services Using the Tree Tab or Layout Tab
    •  Creating a New Flow Service
      • Creating an Empty Flow Service
      • Creating a Flow Service from an XML Document, DTD, or XML Schema
      • Creating a Flow Service from an XML Document
      • Creating a Flow Service from a DTD
      • Creating a Flow Service from an XML Schema Definition
      • Inserting Flow Steps
      • Changing the Position of a Flow Step
      • Changing the Level of a Flow Step
    • Setting Properties for a Flow Step
    •  The INVOKE Step
      • Specifying the Service Property
      • Invoking a Built-In Service
      • Invoking a Service on Another Integration Server
      • Building an Invoke Step
    •  The BRANCH Step
      •  Branching on a Switch Value
        • Specifying the Switch Value
        • Specifying the Label Value
      • Branching on an Expression
      • Branching on Null and Empty Values
      • Specifying a Default Step
      • Using a SEQUENCE as the Target of a BRANCH
      • Building a BRANCH Step
    •  The REPEAT Step
      • Specifying the REPEAT Condition
      • Setting the REPEAT Counter
      • When Does REPEAT Fail?
      • Using REPEAT to Retry a Failed Step
      • Using REPEAT to Retry a Successful Step
    •  The SEQUENCE Step
      • Using SEQUENCE to Specify an Exit Condition
    •  The LOOP Step
      • Specifying the Input Array
      • Collecting Output from a LOOP Step
      • About the Pipeline for a LOOP Step
      • Building a LOOP Step
    •  The EXIT Step
      • Exiting on Success or Failure
      •  Exiting from Iterations, Steps, or Services
        • Java Equivalents for EXIT Behavior
      • Building an EXIT Step
    • The MAP Step
    • The TRY, CATCH, and FINALLY Steps
    • Printing a Flow Service
    • Comparing Flow Services
  •  Working in the Layout Tab
    •  What Is the Layout Tab
      • When Should You Use Layout Tab?
    •  What Does a Flow Service Look Like in the Layout Tab?
      • Viewing Flow Steps in the Layout Tab
      • Viewing Steps that Contain Child Steps in the Layout Tab
    • Show or Hide the Grid Lines in the Flow Service Editor
    •  Building a Flow Service in the Layout Tab
      •  Inserting a Flow Step
        • Inserting a Flow Step Using the Palette View
        • Inserting a Flow Step Using the Context Menu
      • Notes for Inserting a Child Step into a BRANCH Step
      • Changing the Order of Steps in a Flow Service
  •  Mapping Data in Flow Services
    •  What Does the Pipeline View Contain?
      • Pipeline View for an INVOKE Step
      • Pipeline View for a MAP Step
      • Scrolling in Pipeline View
      • Viewing Full Namespace Path of Referenced Document Types
      • Printing the Pipeline
    • Basic Mapping Tasks
    •  About Linking Variables
      • Creating a Link Between Variables
      •  What Happens When Integration Server Executes a Link?
        • Example of Copying By Reference
        • Preventing Pipeline Values from Being Overwritten
      • Linking to Document and Document List Variables
      •  Linking Variables of Different Data Types
        • Converting a String List to a Document List in the Pipeline
        • Converting Two String Lists to a Document List in the Pipeline
      •  Linking to and from Array Variables in the Pipeline
        • Creating a Link to or from an Array Variable
        • Default Pipeline Rules for Linking to and from Array Variables
      • Deleting a Link Between Variables
      •  Linking Variables Conditionally
        • Linking Multiple Source Variables to a Target Variable
        • Applying a Condition to a Link
    •  About Assigning Values to Pipeline Variables
      • Assigning a Value to a Pipeline Variable
      • Assigning String Variables to Pipeline Variables
      • Assigning Global Variables to Pipeline Variables
      • Assigning String Variables and Global Variables to the Same Pipeline Variable
      • Copying Assigned Values Between Pipeline Variables
    • Dropping Variables from the Pipeline
    • Adding Variables to the Pipeline
    •  Working with Transformers
      • Using Built-In Services as Transformers
      • Inserting a Transformer
      • Linking Variables to a Transformer
      •  Transformers and Array Variables
        • Example of Dimensionality Mismatch
      • Validating Input and Output for Transformers
      • Copying Transformers
      • Renaming Transformers
      • Debugging Transformers
    •  Testing Flow Steps Before Running a Flow Service
      • Opening the Data Mapper View
      • Testing a Flow Step in the Data Mapper View
    •  Mapping Using ForEach
      • Creating a ForEach Mapping
      • Specifying ForEach Mapping Properties
      • ForEach Mapping Rules
  •  Failure Handling in Flow Services Using the TRY, CATCH, and FINALLY Steps
    •  About Failure Handling in Flow Services
      •  What Happens When a Failure Occurs?
        • com.wm.lang.flow.FlowException versus com.wm.lang.flow.Failure
    •  About the TRY, CATCH, and FINALLY Steps
      • The TRY Step
      • The CATCH Step
      • The FINALLY Step
    •  Usage Patterns for Failure Handling
      • TRY-CATCH
      • TRY-FINALLY
      • TRY-CATCH-FINALLY
    • Summary of TRY, CATCH, and FINALLY Behavior
    •  Normal and Abrupt Completion and Failure of TRY, CATCH, and FINALLY Steps
      • Notable Behavior for Abrupt Completion in TRY, CATCH, and FINALLY Steps
    • Overview of Building the TRY, CATCH, and FINALLY Steps
    •  Limitations for the TRY, CATCH, and FINALLY Steps
      • Positioning Guidelines and Limitations for TRY, CATCH, and FINALLY Steps
      • CATCH Step Considerations
      • EXIT Step Considerations in TRY, CATCH, or FINALLY
    • Building TRY, CATCH, and FINALLY Steps
  •  Performing Data Validation
    • Blueprints or Models Against which Data is Validated
    •  Performing Input/Output Validation
      • Specifying Input/Output Validation via the Input/Output Tab
      • Specifying Input/Output Validation via the INVOKE Step
    • Performing Pipeline Validation
    • Performing Document Validation
    • Performing XML Validation in Integration Server
    • Performing Validation from within a Java Service
    • Validation Errors
    • Validation Exceptions
    • Preventing Running Out of Memory Error During Validation
  •  Building Java Services
    • Overview of Building Java Services
    •  Java Service Editor
      •  Source Tab
        • Protected Sections of a Java Service
        • Editable Sections of a Java Service
    •  Service Development Projects in the Local Workspace
      • About the Service Development Project Name
      • Format of a Service Development Project
    • How Java Services Are Organized on Integration Server
    •  Creating a Java Service
      • Notes about Creating and Editing Java Services in Designer
    • Using an IData Object for the Java Service Input and Output
    •  Generating Java Code from Service Input and Output Parameters
      • Example of Java Code Generated from Service Signature
    • Editing an Existing Java Service
    • Adding Classes to the Service Development Project
    •  Compiling a Java Service
      • Performance When Compiling a Java Service
    •  Generating Code a Java Service Can Use to Invoke a Specified Service
      • Generating Java Code to Invoke a Service
      • Example of Java Code Generated for Invoking a Service
    • Deleting a Java Service
  •  Building Java Services in Your Own IDE
    • How Java Services are Organized on Integration Server
    • Requirements for the Java Service Source Code
    • IData Object for Java Service Input and Output
    •  Adding Comments to Your Java Code for the jcode Utility
      • Example of Code Commented for the jcode Utility
    •  Using the jcode Utility
      • Using jcode make/makeall to Compile Java Source
      • Using jcode frag/fragall to Split Java Source for Designer
      • Using jcode comp to Create Java Source from Fragments
      • Using jcode Shortcut Commands
  •  Building Map Services
    • What Is a Map Service?
    • Building Map Services Using the Tree Tab or Graphical View Tab
    •  Creating a Map Service
      • Creating a Map Service
    • Setting Properties for a Map Service
    • Working in the Graphical View tab
    • Debugging Map Services
  •  Building C/C++ Services
    • The Java Code for a C/C++ Service
    • Overview of Building C/C++ Services
    • Prerequisites for Building C/C++ Services
    •  C/C++ Service Editor
      •  Source Tab
        • Protected Sections of a C/C++ Service
        • Editable Sections of a C/C++ Service
    •  Service Development Projects in the Local Workspace
      • About the Service Development Project Name
      • Format of a Service Development Project
    • How C/C++ Services Are Organized on Integration Server
    •  Creating a C/C++ Service
      • Editing an Existing C/C++ Service
    • Generating C/C++ Code from Service Input and Output Parameters
    • Adding Classes to the Service Development Project
    • Building the C/C++ Source Code
    •  Compiling the C/C++ Source Code
      • Performance When Compiling a C/C++ Service
    • Generating Code a C/C++ Service Can Use to Invoke a Specified Service
    • Debugging C/C++ Services
  •  Building Services from .NET Methods
    • Environment Setup for Creating .NET Services
    •  .NET Service Editor
      • .NET Properties Tab
    • Creating a .NET Service
    • Modifying the .NET Assembly Information
    • Modifying the Class Lifetime for a .NET Service
    • Running a .NET Service in Designer
  •  Building XSLT Services
    • What Is XSLT?
    • What Is an XSLT Service?
    • How Does an XSLT Service Work?
    • What Is a Translet?
    • About the XSLT Service Editor
    • Overview of Building XSLT Services
    • Creating an XSLT Service
    • XSLT Service Signature
    • Running an XSLT Service
    •  Debugging an XSLT Service
      • Creating a Launch Configuration for an XSLT Service
      • Debugging an XSLT Service
    • Guidelines for the XSLT Style Sheet
    •  Using Name/Value Pairs with an XSLT Service
      •  Passing Name/Value Pairs from the Pipeline to the Style Sheet
        • Specifying New Values for Name/Value Pair
        • Defining Name/Value Pair as an XSLT Parameter
      • Passing Name/Value Pairs from the Style Sheet to the Pipeline
      • Sample Style Sheet: Adding Name/Value Pairs to the Pipeline
    • Configuring XSLT Transformer Factory Settings
  •  Building Cloud Connector Services
    • Creating a Cloud Connector Service
    • Editing a Cloud Connector Service for a SOAP-Based Provider
    •  Editing a Cloud Connector Service for a REST-Based Provider
      • Viewing the Constraints Applied to Variables
  •  Building Connector Listeners
    • Creating Connector Listeners
    • Editing Connector Listeners
  •  Running Services
    •  Using Launch Configurations to Run Services
      • Creating a Launch Configuration for Running a Service
    •  Supplying Input Values to a Service
      •  Entering Input for a Service
        • Specifying a Value for a String Variable
        • Specifying Values for a String List Variable
        • Specifying Values for a String Table Variable
        • Specifying Values for a Document Variable that Has Defined Content
        • Specifying Values for a Document Variable with No Defined Content
        • Specifying Values for a Document List Variable
        • Specifying a Value for an Object Variable
        • Specifying Values for an Object List Variable
      • Saving Input Values
      • Loading Input Values
    • Running a Service
    •  Viewing Results from Running a Service
      • Messages Tab
      • Call Stack Tab
      • Pipeline Tab
      • Saving the Results
      • Restoring the Results
      • Running Services from Results view
      • Removing the Results from Results View
      • Pinning a Result to Results View
      • Sorting Results by Element Names in Results View
    • Running Services from a Browser
  •  Debugging Flow Services
    •  About Debugging Flow Services
      • About Debug Sessions
      • About the Debug Perspective
      • About Debug View
    • Creating Launch Configurations for Debugging Flow Services
    • Debugging a Flow Service
    •  Stepping Through Flow Services
      • Stepping Through a Flow Service
      • Stepping Into and Out of a Child Service
      • Stepping Into and Out of a MAP Step
      • Stepping Into and Out of a ForEach Mapping
    •  Using Breakpoints When Debugging Flow Services
      • Breakpoint States
      • Setting and Removing Breakpoints on Flow Step
      • Setting and Removing Breakpoints on a Transformer
      • Enabling and Disabling Breakpoints in a Flow Service
      • Skipping Breakpoints in a Flow Service
    • Disabling and Enabling Flow Steps and Transformers
    • Disabling and Enabling Conditions
    •  Modifying the Flow Service Pipeline while Debugging
      • Changing Variable Values
      • Dropping Variables
    •  Saving and Restoring the Flow Service Pipeline while Debugging
      •  Saving the Flow Service Pipeline while Debugging
        • Saving the Pipeline to a File while Debugging
      •  Restoring the Flow Service Pipeline while Debugging
        • Loading a Saved Pipeline while Debugging
    • Viewing Service Results from a Flow Service Debug Session
    •  Using the Server Log for Debugging
      •  Writing Information to the Server Log
        • Writing an Arbitrary Message to the Log
        • Dumping the Pipeline to the Log
      • Debugging Map Services
  •  Debugging Java Services
    • About Debugging a Java Service while its Class Runs in Designer
    •  About Test Harnesses
      • Creating a Test Harness
    •  About Java Application Launch Configuration
      • Creating a Java Application Launch Configuration
      • Updating a Java Application Launch Configuration
    • How to Suspend Execution of a Java Class while Debugging
    •  Debugging a Java Service while its Class Runs in Designer
      • Viewing Service Results from Debugging a Java Service
    •  About Debugging a Java Service while it Runs in Integration Server
      • Benefits of Debugging Java Services Running in Integration Server
      • Drawbacks of Debugging Java Services Running in Integration Server
      • Setting Up Integration Server Version 9.7 or Later for Remotely Debugging a Java Service
      • Setting Up Integration Server Version 9.0, 9.5.x, or 9.6 for Remotely Debugging a Java Service
      • Creating a Java Project for an IS Package in Designer
      • Creating a Remote Java Application Launch Configuration
      • Debugging a Java Service while it Runs in Integration Server
  •  Working with REST API Descriptors
    •  OpenAPI Based Provider REST API Descriptors
      • Creating a Provider REST API Descriptor from an OpenAPI Document
      • Viewing General Information of the REST API Descriptor
      •  Working with Servers
        • Viewing the Server Details
        • Adding a New Server
        • Removing a Server
        •  Modifying the Server Details of a Server
          • Adding Server Variables
          • Modifying Server Variables
          • Removing Server Variables
      •  Working with Resources
        • Viewing the REST V2 Resources in the REST API Descriptor
        •  Working with Operations
          • About REST Requests
          • About REST Responses
          • About Services
          • About Callbacks
      •  Working with Schemas
        • Viewing the Schemas
      • About JSON Document Types
      •  Working the Security
        • Viewing the Security Schemes
      •  Working the Tags
        • Viewing the Tags
      • Viewing the OpenAPI Document for a REST API Descriptor
    •  Swagger Based Provider REST API Descriptors
      • Approaches for Developing REST Resources
      •  Configuring a REST V2 Resource
        •  Creating a REST V2 Resource
          • Supporting Elements for a REST V2 Resource
          • Configuring REST V2 Resources as JSON API Compliant
          • Examples of Configuring REST Resources Based on JSON API
        •  Working with REST V2 Resource Operation
          • Defining a REST V2 Resource Operation
          • Example of Defining a REST V2 Resource Operation
          • Editing a REST V2 Resource Operation
          • Deleting a REST V2 Resource Operation
        •  Working with REST V2 Resource Attributes
          • Defining a REST V2 Resource Attribute
          • Editing a REST V2 Resource Attribute
          • Deleting a REST V2 Resource Attribute
      • Creating a Provider REST API Descriptor from a REST Resource
      • Editing General Information for a REST API Descriptor
      • Changing the Available MIME Types for a REST API Descriptor
      •  Working with Security Definitions
        • Adding a Security Definition
        • Removing a Security Definition
      •  Working with Tags
        • Adding Tags
        • Removing a Tag
        • Editing a Tag
      •  Working with REST Resources in a REST API Descriptor
        • Adding REST Resources to a REST API Descriptor
        • Removing REST Resources from a REST API Descriptor
        • Setting the Path or Suffix for a REST Resource
        •  Working with Operations
          • Changing the MIME Types for an Operation in a REST Resource
          • Modifying Tags for Operations in a REST Resource
          • Modifying Security Scheme for Operations in a REST Resource
          • Modifying External Document for Operations in a REST Resource
          • About the Operation Parameters
          • Reviewing and Changing the Assigned Source for an Operation Parameter
        •  About Operation Responses
          • Adding an Operation Response
          • Removing an Operation Response
        • Viewing REST V2 Resources in Group by Tags Mode
        •  Running a REST V2 Resource Operation from REST API Descriptor Editor
          • Executing an Operation Using Editor
      • About REST Definitions
      • Viewing the Swagger Document for a REST API Descriptor
      • Creating a Provider REST API Descriptor from a Swagger Document
      • Mapping Integration Server Data Types to Swagger Data Types
      • Mapping Integration Server Content Type Constraints to Swagger Type Constraints
    •  Swagger Based Consumer REST API Descriptors
      • Creating a Consumer REST API Descriptor from a Swagger Document
    • Refreshing a REST API Descriptor
    • Publishing REST API Descriptors to API Portal
  •  Working with OData Services
    • Understanding OData Service Terminology
    • Supported and Unsupported OData Features
    • Overview of Creating an OData Service
    •  Creating an OData Service
      • Creating an OData Service Using an External Source Type
    • Adding OData Elements to the OData Service
    • Adding Properties to the OData Elements
    • Adding Associations to OData Elements
    • Editing the OData Service
    • Synchronizing the External Entity Type
    • How Integration Server Processes an OData Service Request
    • Querying Data Using $filter
  •  Working with Document Types
    •  Creating an IS Document Type
      •  Creating an Empty IS Document Type
        • Adding Fields to an IS Document Type
      •  Creating an IS Document Type from an XML Document, DTD, or XML Schema
        • Creating an IS Document Type from an XML Document
        • Creating an IS Document Type from a DTD
        • Creating an IS Document Type from an XML Schema Definition
      •  Creating IS Document Types from JSON Objects
        • Mapping JSON Data Types
        • Generating Fields from Unquoted Fields in a JSON Object
        • Creating an IS Document Type from a JSON Object
      • Creating an IS Document Type from a Broker Document Type
      •  Creating an IS Document Type from an E-form Template
        • Notes About IS Document Types Created from E-form Templates
      • Creating a Document Type from a Flat File Schema
      • Determining How to Represent Complex Types in Document Types
      •  Derived Types and IS Document Types
        • *doctype Fields in IS Document Types and Document Fields
        • *doctype Fields in IS Document Types
        • *doctype Fields in Document Fields
      • Registering Document Types with Their Schema Types
      • Generating Fields for Substitution Groups
      • *Any Fields in Document Types and Document Fields
      • About Run-time Processing for an IS Document Type that Complies with the Content Model
    • Editing Document Types
    • About Universal Names and Document Types
    • Printing an IS Document Type
    •  Publishing Documents as JMS Messages
      • Creating a Launch Configuration to Publish a Document as a JMS Message
      • Publishing a Document as a JMS Message
  •  Working with Publishable Document Types
    •  Making a Document Type Publishable
      • About the Associated Provider Definition
      • About the Envelope Field
      • About the Properties Field
      • About Adapter Notifications and Publishable Document Types
    • Making a Document Type Unpublishable
    •  About the Encoding Type for a Publishable Document Type
      •  Using Protocol Buffers as the Encoding Type
        • Limitations for Representing Fields in Protocol Buffer Descriptors
      • Encoding Documents as Protocol Buffers during Document Publishing
      • Decoding Protocol Buffers
      • Setting the Encoding Type for a Publishable Document Type
      • Encoding IData as XML When Publishing to Universal Messaging
    •  About the Type of Document Storage
      • Document Storage Versus Broker Client Queue Storage
      • Setting the Document Storage Type for a Publishable Document Type
    •  About the Time-to-Live for a Publishable Document Type
      • Setting the Time to Live for a Publishable Document Type
    •  About Run-Time Validation for a Published Document
      • Specifying Document Validation for Instances of a Publishable Document Type
    • Important Considerations When Modifying Publishable Document Types
    •  About Synchronizing Publishable Document Types
      • Synchronization Status
      • Synchronization Actions
      • Combining Synchronization Action with Synchronization Status
      • Synchronizing a Single Publishable Document Type
      • Synchronizing Multiple Document Types Simultaneously
      • Synchronizing Document Types in a Cluster
      • Synchronizing Document Types Across a Gateway
      •  Importing and Overwriting References During Synchronization
        • What Happens When You Overwrite Elements on the Integration Server?
        • What Happens If You Do Not Overwrite Elements on the Integration Server?
    •  About Testing Publishable Document Types
      • Creating a Launch Configuration for a Publishable Document Type
      • Testing a Publishable Document Type
    • Deleting Publishable Document Types
  •  Working with XML Document Types
    •  What Is an XML Document Type?
      • What Is XMLData?
    •  Why Use XML Document Types Instead of IS Document Types?
      • Differences Between XML Document Types and IS Document Types
      • Limitations of XML Document Type Usage
    • Creating an XML Document Type
  •  Working with JSON Document Types
    • What Is a JSON Document Type?
    • Considerations for Using JSON Document Types
    • Data Type Mapping
    • Creating a JSON Document Type
    • JSON Document Type Properties
  •  Working with Specifications
    • Creating a Specification
  •  Working with Variables
    • Creating a Document Reference or a Document Reference List Variable
    •  Using XML Namespaces and Namespace Prefixes with Variables
      • Guidelines for Using XML Namespaces and Prefixes with Web Service Descriptors
      • Assigning XML Namespaces and Prefixes to Variables
    • Assigning Display Types to String Variables
    •  About Variable Constraints
      • Considerations for Object Constraints
      • Applying Constraints to a Variable
      • Customizing a String Content Type
      • Viewing the Constraints Applied to Variables
  •  Working with Schemas
    •  What Does an IS Schema Look Like?
      • Schema Browser
      • Component Details
    •  Creating an IS Schema
      • Creating an IS Schema from XML Schemas that Reference Other Schemas
    •  About Editing Simple Type Definitions
      • Editing a Simple Type Definition
    • About Schema Domains
    • XML Schema 1.0 Support in Integration Server
    •  XML Schema 1.1 Support in Integration Server
      • Supported Features from XML Schema 1.1
      • Unsupported Features from XML Schema 1.1
  •  Working with JMS Triggers
    • About SOAP-JMS Triggers
    • Overview of Building a Non-Transacted JMS Trigger
    • Standard JMS Trigger Service Requirements
    •  Creating a JMS Trigger
      •  Adding JMS Destinations and Message Selectors to a JMS Trigger
        • Creating a Destination on the JMS Provider
        • About Durable and Non-Durable Subscribers
        • Creating a Message Selector
      •  Adding Routing Rules to a Standard JMS Trigger
        • Creating a Local Filter
    •  Managing Destinations and Durable Subscribers on the JMS Provider through Designer
      • Modifying Destinations or Durable Subscribers via a JMS Trigger in Designer
    •  Building Standard JMS Triggers with Multiple Routing Rules
      • Guidelines for Building a JMS Trigger that Performs Ordered Service Execution
    •  Enabling or Disabling a JMS Trigger
      • JMS Trigger States
    • Setting an Acknowledgement Mode
    •  About Join Time-Outs
      • Join Time-Outs for All (AND) Joins
      • Join Time-Outs for Only One (XOR) Joins
      • Setting a Join Time-Out
    •  About Execution Users for JMS Triggers
      • Assigning an Execution User to a JMS Trigger
    •  About Message Processing
      • Serial Processing
      • Concurrent Processing
      •  Message Processing and Message Consumers
        • Message Processing and Load Balancing
      •  About Batch Processing for Standard JMS Triggers
        • Guidelines for Configuring Batch Processing
      • Using Multiple Connections to Retrieve Messages for a Concurrent JMS Trigger
      •  Retrieving Multiple Messages for a JMS Trigger with Each Request
        • Prefetching Messages from webMethods Broker
        • Prefetching Messages with Universal Messaging
      • Configuring Message Processing
    •  Fatal Error Handling for Non-Transacted JMS Triggers
      • Configuring Fatal Error Handling for Non-Transacted JMS Triggers
    •  Transient Error Handling for Non-Transacted JMS Triggers
      • About Retry Behavior for Trigger Services
      • Service Requirements for Retrying a Trigger Service
      •  Handling Retry Failure
        • Overview of Throw Exception for Retry Failure
        • Overview of Suspend and Retry Later for Retry Failure
      • Configuring Transient Error Handling for a Non-Transacted JMS Trigger
    •  Exactly-Once Processing for JMS Triggers
      • Duplicate Detection Methods for JMS Triggers
      •  Configuring Exactly-Once Processing for a JMS Trigger
        • Disabling Exactly-Once Processing for a JMS Trigger
    • Debugging a JMS Trigger
    •  Building a Transacted JMS Trigger
      • Prerequisites for a Transacted JMS Trigger
      • Properties for Transacted JMS Triggers
      • Steps for Building a Transacted JMS Trigger
      •  Fatal Error Handling for Transacted JMS Triggers
        • Configuring Fatal Error Handling for Transacted JMS Triggers
      •  Transient Error Handling for Transacted JMS Triggers
        • Overview of Recover Only for Transaction Rollback
        • Overview of Suspend and Recover for Transaction Rollback
        • Configuring Transient Error Handling for Transacted JMS Triggers
  •  Working with webMethods Messaging Triggers
    •  Overview of Building a webMethods Messaging Trigger
      • webMethods Messaging Trigger Requirements
      • Trigger Service Requirements
    •  Creating a webMethods Messaging Trigger
      • Creating Conditions
      • Using Filters with a Subscription
      •  Creating Filters for Use with Universal Messaging
        • Universal Messaging Provider Filters and Encoding Type
        • Examples of Universal Messaging Provider Filters for Use with Protocol Buffers
      •  Creating Filters for Use with webMethods Broker
        • Using Hints in Filters
        • Detecting Deadletters with Hints
      •  Using Multiple Conditions in a webMethods Messaging Trigger
        • Using Multiple Conditions for Ordered Service Execution
        • Ordering Conditions in a webMethods Messaging Trigger
    •  Disabling and Enabling a webMethods Messaging Trigger
      • Disabling and Enabling a webMethods Messaging Trigger in a Cluster or Non-Clustered Group
    •  About Join Time-Outs
      • Join Time-Outs for All (AND) Join Conditions
      • Join Time-Outs for Only One (XOR) Join Conditions
      • Setting a Join Time-Out
    •  About Priority Message Processing
      • Enabling and Disabling Priority Message Processing for a webMethods Messaging Trigger
    •  About Execution Users for webMethods Messaging Triggers
      • Assigning an Execution User to a webMethods Messaging Trigger
    •  About Capacity and Refill Level for the webMethods Messaging Trigger Queue
      • Guidelines for Setting Capacity and Refill Levels for webMethods Messaging Triggers
      • Setting Capacity and Refill Level for a webMethods Messaging Trigger
    •  About Document Acknowledgements for a webMethods Messaging Trigger
      • Setting the Size of the Acknowledgement Queue
    •  About Message Processing
      •  Serial Processing
        •  Serial Processing in a Cluster or Non-Clustered Group of Integration Servers
          • Serial Processing with the webMethods Broker in a Clustered or a Non-Clustered Group of Integration Servers
          • Serial Processing with Universal Messaging in a Clustered or a Non-Clustered Group of Integration Servers
        • Serial Triggers Migrated to Integration Server 10.3 or Later from Earlier Versions
      • Concurrent Processing
      • Selecting Message Processing
      • Changing Message Processing When webMethods Broker Is the Messaging Provider
      •  Changing Message Processing When Universal Messaging Is the Messaging Provider
        • Synchronizing the webMethods Messaging Trigger and Durable Subscription on Universal Messaging
    •  Fatal Error Handling for a webMethods Messaging Trigger
      • Configuring Fatal Error Handling for a webMethods Messaging Trigger
    •  About Transient Error Handling for a webMethods Messaging Trigger
      • Service Requirements for Retrying a Trigger Service for a webMethods Messaging Trigger
      •  Handling Retry Failure
        • Overview of Throw Exception for Retry Failure
        • Overview of Suspend and Retry Later for Retry Failure
      • Configuring Transient Error Handling for a webMethods Messaging Trigger
      • About Retrying Trigger Services and Shutdown Requests
    •  Exactly-Once Processing for webMethods Messaging Triggers
      • Duplicate Detection Methods for a webMethods Messaging Trigger
      • Configuring Exactly-Once Processing for a webMethods Messaging Trigger
      • Disabling Exactly-Once Processing for a webMethods Messaging Trigger
    •  Modifying a webMethods Messaging Trigger
      • Modifying a webMethods Messaging Trigger in a Cluster or Non-Clustered Group
    •  Deleting webMethods Messaging Triggers
      • Deleting webMethods Messaging Triggers in a Cluster or Non-Clustered Group
    •  Running a webMethods Messaging Trigger with a Launch Configuration
      • Creating a Launch Configuration for a webMethods Messaging Trigger
      • Running a webMethods Messaging Trigger
      • Testing Join Conditions
    •  Debugging a webMethods Messaging Trigger
      • Enabling Trace Logging for All webMethods Messaging Triggers
      • Enabling Trace Logging for a Specific webMethods Messaging Trigger
  •  Transient Error Handling During Trigger Preprocessing
    • Server and Trigger Properties that Affect Transient Error Handling During Trigger Preprocessing
    • Overview of Transient Error Handling During Trigger Preprocessing
  • How Triggers Correspond to Durable Subscribers on Universal Messaging
  •  Working with MQTT Triggers
    • Overview of Building an MQTT Trigger
    • MQTT Trigger Requirements
    • MQTT Trigger Service Requirements
    • Creating an MQTT Trigger
    •  Disabling and Enabling an MQTT Trigger
      • MQTT Trigger States
    • Setting an Acknowledgement Mode for an MQTT Trigger
    • Assigning an Execution User to an MQTT Trigger
    • Configuring Message Processing for an MQTT Trigger
    •  Transient Error Handling for an MQTT Trigger
      • Service Requirements for Retrying an MQTT Trigger
      •  Handling Retry Failure
        • Overview of Throw Exception
        • Overview of Stop Trigger
      • Configuring Transient Error Handling for an MQTT Trigger
      • Building a Resource Monitoring Service for an MQTT Trigger
    • Modifying an MQTT Trigger
    • Deleting an MQTT Trigger
  •  Working with Web Services
    • What Are Web Service Descriptors?
    •  About Provider Web Service Descriptors
      •  Service Signature Requirements for Service First Provider Web Service Descriptors
        • Using XML Namespaces with Prefixes with Fields in Service Signatures
        • Handling Incomplete Service Signatures Using Wrapper Services
      •  Creating a Service First Provider Web Service Descriptor
        • Protocol Mismatch Between Transport and Primary Port
      • Creating a WSDL First Provider Web Service Descriptor
    •  About Consumer Web Service Descriptors
      •  Creating a Consumer Web Service Descriptor
        • Supporting Elements for a Consumer Web Service Descriptor
      • About Web Service Connectors
      • Refreshing a Web Service Connector
      • Invoking a Web Service Using a Web Service Connector
      • About Response Services
    •  About Refreshing a Web Service Descriptor
      • How Refresh Affects a Web Service Descriptor
      • Considerations for Refreshing a Web Service Descriptor
      • Refreshing a Web Service Descriptor
    • Viewing the WSDL Document for a Web Service Descriptor
    •  WS-I Compliance for Web Service Descriptors
      • Modifying WS-I Compliance for a Web Service Descriptor
      • Reporting the WS-I Profile Conformance for a Web Service Descriptor
    • Changing the Target Namespace for a Web Service Descriptor
    • Viewing the Namespaces Used within a WSDL Document
    •  Enabling MTOM/XOP Support for a Web Service Descriptor
      • Enabling SOAP Attachments for a Web Service Descriptor
      • Using pub.string:base64Encode with MTOM Implementations
    • Adding SOAP Headers to the Pipeline
    • Validating SOAP Response
    •  Validating Schemas Associated with a Web Service Descriptor
      • Enabling Xerces Schema Validation for a Web Service Descriptor
    • Omitting xsd:any from the WSDL Document
    •  Working with Binders
      •  Binders and Mixed Use
        • Existing Web Service Descriptors with Mixed Use Binders
      • Binders and Mixed Style
      • Adding a Binder to Web Service Descriptor
      • Copying Binders Across Provider Web Service Descriptors
      • Changing the Binder Transport
      • Deleting a Binder from a Web Service Descriptor
      • Deleting an Operation from a Binder
      • Modifying the SOAP Action for an Operation in a Binder
      • Assigning a Web Service Endpoint Alias to a Binder
      • Configuring Use of the Client Side Queue
    •  Working with Operations
      •  Adding Operations
        • Adding an IS Service as an Operation
        • Adding an Operation from another Provider Web Service Descriptor
        •  Using a 6.5 SOAP-MSG Style Service as an Operation
          • Modifying the Signature of a 6.5 SOAP-MSG Style Operation
      • Deleting Operations
      • Viewing the Operation Input and Output
    •  Adding Headers to an Operation
      • Adding a Header to an Operation
    •  About SOAP Fault Processing
      •  About SOAP Fault Elements
        • Adding a Fault Element to an Operation
      • The $fault Variable
      • Modifying a Returned SOAP Fault
    • Viewing Document Types for a Header or Fault Element
    •  Working with Handlers
      • Setting Up a Header Handler
      • Registering a Header Handler
      • Adding a Handler to a Web Service Descriptor
      • Deleting a Handler from a Web Service Descriptor
    •  Working with Policies
      • Attaching a Policy to a Web Service Descriptor
      • Removing a Policy from a Web Service Descriptor
    •  About Pre-8.2 Compatibility Mode
      • Setting Compatibility Mode
      • Features Impacted by Compatibility Mode
  •  Working with GraphQL Descriptors
    • Understanding the GraphQL Terminology
    • Supported and Unsupported GraphQL Features
    • GraphQL Data Type Mapping
    • Overview of Creating a GraphQL Descriptor
    •  Creating a GraphQL Descriptor
      • How Integration Server Generates GraphQL Descriptor and Supporting Assets
      • How Integration Server Generates Input Signature for Resolver Services
      • How Integration Server Generates Output Signature for Resolver Services
      • How Integration Server Invokes a Resolver Service While Processing a GraphQL Request
      • Usage Notes for GraphQL Descriptors
    •  Invoking a GraphQL Descriptor
      • Working with GET Request
      • Working with POST Request
      • How Integration Server Sends Response to a GraphQL Request
    •  Modifying Properties to the GraphQL Descriptor
      • How Integration Server Calculates the Query Parameters
    • Refreshing a GraphQL Descriptor
    • Working with a GraphQL Dataloader
    • Creating a Dataloader
    •  How Integration Server Uses Dataloader in Resolver Service
      • Using personLoader in listPersonResolver Root Resolver Service
      • Using personLoader in friendsResolver Resolver Service
  •  Working with WebSocket Endpoints
    • Creating a WebSocket Server Endpoints
    • Creating a WebSocket Client Endpoint
  •  Working with Recipes
    • Installing or Downloading Recipes
  •  Working with UDDI Registry
    • Opening UDDI Registry View
    • Connecting to a UDDI Registry
    • Disconnecting from a UDDI Registry
    • Refreshing a UDDI Registry Session
    •  Browsing for Web Services in a UDDI Registry
      • Applying a Filter to UDDI Registry
      • Clearing an Applied Filter
    • Creating a Web Service Descriptor from a UDDI Registry
    • Publishing a Service to UDDI Registry
    • Deleting a Service from UDDI Registry
  •  Working with Flat Files
    •  Concepts
      • What Is a Flat File Schema?
      •  What Is a Flat File Dictionary?
        • When Should I Create a Flat File Dictionary?
    •  Creating Flat File Schemas
      •  Creating the Flat File Schema
        • Creating a Flat File Schema From a Sample File
        • Creating a Flat File Schema Manually
      •  Specifying a Record Parser
        • Specifying a Delimited Record Parser for the Schema
        • Specifying a Fixed Length Record Parser for the Schema
        • Specifying a Variable Length Record Parser for the Schema
      • Specifying a Record Identifier
      • Defining the Schema Structure
      • Setting a Default Record
      • Allowing Undefined Data
      • Creating an Area
      • Specifying a Floating Record
      • Editing a Flat File Schema
    •  Testing Flat File Schemas
      • Creating a Launch Configuration for a Flat File Schema
      • Testing a Flat File Schema
    •  Creating Flat File Dictionaries
      • Creating a Flat File Dictionary
      • Adding Elements to the Flat File Dictionary
      • Setting Properties for the Flat File Dictionary
      • Editing a Flat File Dictionary
    •  Defining Flat File Elements
      • Adding a Record Definition
      • Adding a Record Reference
      • Adding a Composite Definition
      • Adding a Composite Reference
      • Adding a Field Definition
      • Adding a Field Reference
  •  Working with Adapters
    • About Adapter Connections
    • About Adapter Services
    • About Adapter Listeners
    • About Adapter Notifications
  •  Subscribing to Events
    • What Happens When an Event Occurs?
    •  Subscribing to Events
      • Creating Event Filters
      • Creating Event Filters for Services
    • Viewing and Editing Event Subscriptions
    • Suspending Event Subscriptions
    • Deleting an Event Subscription
    • Building an Event Handler
    • Invoking Event Handlers Synchronously or Asynchronously
    • About Alarm Events
    • About Audit Events
    • About Audit Error Events
    • About Exception Events
    •  About Guaranteed Delivery Events
      • Guaranteed Delivery Events and Transaction Events
    • About JMS Delivery Failure Events
    • About JMS Retrieval Failure Events
    • About Port Status Events
    • About Replication Events
    • About Security Events
    • About Session Events
    • About Stat Events
    • About Transaction Events
  •  Submitting and Receiving XML Documents
    •  Submitting and Receiving XML in a String Variable
      • Sample Client Code to Submit an XML Document in a String Variable
      • Considerations When Coding the Target Service to Receive the XML Document that is Passed in a String Variable
    •  Submitting and Receiving XML in $xmldata
      • Sample Client Code to Submit an XML Document in $xmldata
      • Considerations When Coding the Target Service to Receive the XML Document that is Passed in $xmldata
    •  Submitting and Receiving XML via HTTP
      • Creating a Client that Submits an XML Document via HTTP
      • Using pub.client:http to Submit an XML Document via HTTP
      • About the xmlFormat Value
      •  Submitting and Receiving XML via $xmldata without Parsing
        • Using pub.client:http to Submit $xmldata via HTTP
    •  Submitting and Receiving XML via FTP
      • Naming the File that the Client is to Submit via FTP
      • Actions a Client Takes to Submit an XML Document via FTP
      • Actions a Client Takes to Retrieve Output from the Target Service
      • Considerations When Coding the Target Service to Receive the XML Document
    •  Submitting and Receiving XML via E-mail
      • Actions a Client Must Take to Submit an XML Document via Email
      • Using pub.client:smtp to Submit an XML Document via Email
      • Considerations When Coding the Target Service to Receive the XML Document
  •  Working with Load and Query Services
    • What Are the Load and Query Services?
    • Basic Concepts
    • About the pub.xml:loadXMLNode Service
    • About the pub.xml:loadEnhancedXMLNode Service
    • About the pub.xml:queryXMLNode Service
  •  Building Services that Retry
    • Requirements for Retrying a Service
    • Example Service that Throws an Exception for Retry
  •  Creating Client Code
    •  Building a Java Client
      • Limitations when Generating Java Client Code
      • Files that Designer Generates for a Java Client
      • Generating Java Client Code
    •  Building a C/C++ Client
      • Prerequisites for Generating C/C++ Client Code
      • Limitations when Generating C/C++ Client Code
      • Files that Designer Generates for a C/C++/C# Client
      • Generating C/C++/C# Client Code
    •  Building a Browser-Based Client
      • Prerequisites for Building Browser-Based Client Code
      • URL Client Uses to Invoke Services
      •  How Input Values are Passed to the Service the Browser-Based Client Invokes
        • When Browser-Based Clients Pass Multiple Values for the Same Input Variable
        • When Browser-Based Clients Pass Multiple Input Variables with the Same Name
      • How Integration Server Returns Output from the Service the Client Invoked
    • Building a REST Client
  •  Comparing Integration Server Packages and Elements
    •  Working with the Compare Editor
      • Change List Panel
      • Content Panel
    •  Guidelines for Comparing Packages, Folders, and Elements
      •  Comparing Integration Server Elements
        • Merging IS Elements
      • Comparing Integration Server Folders
    • Comparing Integration Server Packages
  •  Publishing and Retracting Metadata for IS and TN Assets
    • Available IS and TN Assets
    •  Publishing and Retracting Metadata
      • Considerations for Publishing and Retracting Metadata
      • Publishing Metadata for IS Assets or TN Document Types at the Integration Server Level
      • Retracting Metadata for IS Assets or TN Document Types at the Integration Server Level
      • Publishing Metadata for IS Assets or TN Document Types at the Asset Level
      • Retracting Metadata for IS Assets or TN Document Types at the Asset Level
      • Usage Notes for IS Assets
    • Status Information for Publish and Retract Requests
    • Summary Information for Publish and Retract Requests
  •  Connecting to webMethods API Portal for Publishing REST API Descriptors
    •  Configuring a Connection to API Portal
      • Adding a Connection Configuration for API Portal
      • Editing a Connection Configuration for API Portal
      • Removing a Connection Configuration for API Portal
      • Changing the Default Connection Configuration for API Portal
  •  Publishing Assets to webMethods API Gateway
    •  Configuring a Connection to API Gateway
      • Editing a Connection Configuration for API Gateway
      • Removing a Connection Configuration for API Gateway
      • Changing the Default Connection Configuration for API Gateway
      • Publishing Assets to API Gateway
  •  Connecting to webMethods Cloud Container
    •  Configuring a Connection to Cloud Container
      • Adding a Connection Configuration for Cloud Container
      • Editing a Connection Configuration for Cloud Container
      • Removing a Connection Configuration for Cloud Container
  •  Deploying to webMethods Cloud Container
    •  Deploying Packages and Configuration Assets to Cloud Container
      • Checking the Deployment Status
    •  Asset Repository
      • Opening the Asset Repository View
      • Building Packages and Assets in Asset Repository View
      • Deploying Packages and Assets from Asset Repository View
      • Retracting Packages and Assets
      • Deleting Packages and Assets
    •  Configuring a Universal Messaging Server
      • Modifying a Universal Messaging Server
      • Removing a Universal Messaging Server
    •  Using Landscape Navigator to View Runtime Configurations (Deprecated)
      • What Does the Landscape Navigator View Contain?
      •  Creating Command Central Definitions
        • Editing Command Central Definition
        • Deleting a Command Central Definition
      • What Does the Configuration Browser View Contain?
      • Browsing Runtime Instances and Configurations
      • Deploying Customized Configuration to Cloud Container
      • Exporting Deployable Configuration
      • Using Configuration Project
      • Editing Configuration Template
      • Deploying a Configuration Project
  •  Using the Cloud Service Development Feature
    • Prerequisites
    • Opening the Cloud Service Development Perspective
    • The Cloud Explorer View
    • Supported and Unsupported Functions
  • API Portal Preferences
  •  Command Central Preferences
    • Command Central Connection Configuration
    • Labels and Decorations
    • Monitoring
    • Projects
  • Document Expansion Preferences
  • Cloud Container Preferences
  • Integration Server Preferences
  • Universal Messaging Preferences
  •  Service Development Preferences
    • Adapter Service/Notification Editor Preferences
    • Compare Editor Preferences
    • Element Property Templates Preferences
    • Flow Service Editor Preferences
    • HTML Generation Preferences
    • Java/C Service Editors Preferences
    • Launching Preferences
    • Local Service Development Preferences
    • Package Navigator Preferences
    • Publishable Document Type Preferences
    • Results View Preferences
    • Run/Debug Preferences
    • Schema Editor Preferences
    • Swagger Syntax Coloring Preferences
    • Web Service Descriptor Editor Preferences
  •  Properties
    •  Integration Server Properties
      • Event Manager Properties
      • My Locked Elements
      • Server ACL Information
      • Server Information
    •  Package Properties
      • Package Information
      • Package Dependencies
      • Package Settings
      • Package Permissions
      • Package Replication Services
      • Package Startup/Shutdown Services
    •  Element Properties
      • Element Information
      • Element Permissions
      • Element General Properties
      • REST Resource Configuration
    •  Document Type Properties
      • General Properties for IS Document Types
      • JSON Document Type Properties
      • webMethods Messaging Properties
      • Universal Name Properties
    •  Flat File Dictionary Properties
      • General Properties for a Flat File Dictionary
    •  Flat File Element Properties
      • Record Definition Properties
      • Record Reference Properties
      • Composite Definition Properties
      • Composite Reference Properties
      • Field Definition Properties
      • Field Reference Properties
    •  Flat File Schema Properties
      • General Properties for a Flat File Schema
      • Default Record Properties
      • Settings Properties
      • Schema Definition Properties
    •  JMS Trigger Properties
      • General Properties for Non-Transacted JMS Triggers
      • General Properties for Transacted JMS Triggers
      • Message Processing Properties
      • Fatal Error Handling Properties
      • Transient Error Handling with a Non-Transacted JMS Trigger
      • Transient Error Handling with a Transacted JMS Trigger
      • Exactly Once Processing Properties
      • Universal Messaging and webMethods Broker Properties
    •  Link Properties
      • General Properties for Links
    •  MQTT Trigger Properties
      • General Properties for an MQTT Trigger
      • Message Processing Properties
      • Transient Error Handling Properties
    •  OData Service Properties
      • General Properties for OData Services
      •  OData Element Properties
        • Entity Type Properties
        • Complex Type Properties
      • External Entity Type Properties
      •  Simple Property Properties
        • General Properties for Simple Property
        • Facets Properties for Simple Property
      • Complex Property Properties
      •  Association Properties
        • General Properties for Association
        • OData Association End Properties
        • OData Association Navigation Properties
    • REST V2 Resource Properties
    •  REST API Descriptor Properties
      • General Properties for REST API Descriptors
      • REST Resource Properties
      • Operation Properties
      • REST Definition Properties
      • REST Definition Parameter Properties
    •  Schema Properties
      • General Properties for IS Schemas
    •  Schema Component Properties
      • All Content Model
      • Any Attribute Declaration
      • Any Element Declaration
      • Attribute Declaration
      • Attribute Reference
      • Choice Content Model
      • Complex Type Definition
      • Element Declaration
      • Element Reference
      • Empty Content
      • Mixed Content Model
      • Sequence Content Model
      • Simple Type Definition
    •  Service Properties
      • General Properties for Services
      • Run Time Properties for Services
      • Transient Error Handling Properties
      • Audit Properties
      • Circuit Breaker Properties
      • Universal Name Properties for Services
      • Output Template Properties for Services
    •  Specification Properties
      • General Properties for Specifications
    •  Transformer Properties
      • General Properties for Transformers
    •  Variable Properties
      • General Properties for Variables
      • Constraints Properties for a Variable
      • Constraints Applied to Variables
    •  webMethods Messaging Trigger Properties
      • General Properties for webMethods Messaging Triggers
      • Trigger Queue Properties
      • Message Processing Properties
      • Fatal Error Handling Properties
      • Transient Error Handling Properties
      • Exactly Once Properties
    •  Web Service Connector Properties
      • General Properties for Web Service Connectors
      • Run Time Properties
      • Audit Properties
      • Universal Name Properties
      • Output Template Properties
    •  Web Service Descriptor Properties
      • General Properties for Web Service Descriptors
      •  Web Service Descriptor Operation Properties
        • Operation Properties
        • Body Element Properties
        • Header Element Properties
        • Fault Element Properties
      •  Web Service Descriptor Binder Properties
        • General Properties for Binders
        • JMS Settings Properties for a Binder
        • JMS Message Details Properties for a Binder
      • Web Service Descriptor Header Handler Properties
    •  GraphQL Descriptor Properties
      • Query Properties for GraphQL Descriptor
      • GraphQL Dataloaders
    • WebSocket Endpoint Properties
  •  webMethods Flow Steps
    •  BRANCH
      • Branching on a Switch Value
      • Branching on Expressions
      • BRANCH Properties
      • Conditions that Will Cause a BRANCH Step to Fail
    •  CATCH
      • CATCH Properties
    •  EXIT
      • EXIT Properties
      • Examples of When to Use an EXIT Step
    •  FINALLY
      • FINALLY Properties
    •  INVOKE
      • INVOKE Properties
      • Conditions that Will Cause an INVOKE Step to Fail
    •  LOOP
      • LOOP Properties
      • Conditions that Will Cause a LOOP Step to Fail
    •  MAP
      • MAP Properties
      • Example of When to Use a MAP Step
    •  REPEAT
      • REPEAT Properties
      • When Does REPEAT Fail?
      • Examples of When to Use a REPEAT Step
    •  SEQUENCE
      • SEQUENCE Properties
      • Conditions that Will Cause the SEQUENCE Step to Fail
    •  TRY
      • TRY Properties
  •  Data Types
    • Data Types in IData Objects
    • Java Classes for Objects
    • How Designer Supports Tables
  •  Icons
    • Package Navigator View Icons
    • UDDI Registry View Icons
    • Flat File Element Icons
    • Flow Step Icons
    • OData Service Icons
    • REST API Descriptor Icons
    • Schema Component Icons
  •  Toolbars
    • Compare Editor Toolbar
    • Document Type Editor Toolbar
    • Flat File Schema and Dictionary Editors Toolbars
    • Package Navigator View Toolbar
    • Cloud Explorer View Toolbar
    • Pipeline View Toolbar
    • REST API Descriptor Toolbar
    • GraphQL Descriptor Toolbar
    • Service Editor Toolbar
    • Results View Toolbar
    • Specification Editor Toolbar
    • UDDI Registry View Toolbar
    • Variables View Toolbar
    • Web Service Descriptor Editor Toolbar
  • Keyboard Shortcuts
  •  Conditional Expressions
    • Guidelines for Writing Expressions and Filters
    •  Syntax
      • Comparing Java Objects to Constants
      • Verifying Variable Existence
    •  Operators for Use in Conditional Expressions
      •  Relational Operators
        • Standard Relational Operators
        • Lexical Relational Operators
      • Logical Operators
    • Operator Precedence in Conditional Expressions
    •  Addressing Variables
      •  Addressing Variables that Contain Special Characters
        • Typing Special Characters in Expressions
    • Rules for Use of Expression Syntax with the Broker
  •  Regular Expressions
    • Using a Regular Expression in a Mask
    • Regular Expression Operators
  •  Validation Content Constraints
    • Content Types
    • Constraining Facets
  •  webMethods Query Language
    • Overview
    • Object References
    • Sibling Operators
    • Object Properties
    • Property Masking
  •  Appendix
    •  Usage Notes on REST
      •  Configuring a REST Resource Using the Legacy Approach
        • Processing Requests Using Partial Matching of URL Aliases
        •  Setting Up a REST Application on Integration Server
          • Services for REST Resources Configured Using the Legacy Approach
          • Configuration
          • Converting an Existing Application to a REST Application
      • Examples of Configuring REST Resources Based on JSON API
      • Example of Defining a REST V2 Resource Operation
    • Usage Notes on REST API Descriptor
•  Unit Test Framework
  • About this Guide
  •  Unit Test Framework
    • Overview
    •  Terms and Concepts
      • Services
      • Pipeline
      • Unit Testing
      • Test Case
      • Test Suite
      • Mock
      • Service Mock
      • Exception Mock
      • Factory Mock
    • Capabilities
    • Server Definition
    • Environment
    • What it is not
  •  Working with Unit Test Framework
    • Opening the Unit Test Framework Perspective
    • Layout
    •  Test Suite Preferences
      • Advanced
      • License
      • Editor
      • Validation
  •  Creating a Test Suite
    • Before You Begin
    • To Create a Test Suite
    • Creating a Sample Test Suite
  •  Adding Test Cases
    • Adding a Test Case
    • Test Details
    • Service Details
    • Inputs
    • Expected Output
    • Output Comparison
  •  Generating Tests
    • Generating Tests Suites using Service Execution Results
  •  Mocks
    • Using Mocks
    • Sample Mock Factory
    • Mocks Beyond Unit Testing
  •  Advanced Options
    • Pipeline Filter
    • Comparators
    • Client Mock Factory
    • XPath Expressions
  •  Test Suite Internals
    • Test Suite Internals
  •  Java Unit Tests
    • Java Unit Tests
  •  Executing Tests
    • Executing Test Cases
    • Executing Test Suites
    • Debugging Java Code
    •  Continuous Integration
      • Creating a Test Suite Executor
      • Configuring a Test Suite Executor
      • View JUnit Test Results and Code Coverage Reports
  •  Code Coverage Analysis
    • Running a Coverage Analysis
    • Viewing Code Coverage Analysis
    • Viewing Mock Event Details
    • Defining the Coverage Scope
    • Coverage Analysis in Headless Mode
  •  Service Usage
    • WmServiceMock Services
    • References
•  Application Platform User Guide
  • About this Guide
  •  About Application Platform
    •  Architecture and Components
      • Software AG Common Platform
      • Software AG Designer
      • Software AG Servers
      • webMethods Deployer
    • Publishing and Deploying Bundles
  •  Developing with Application Platform in Designer
    •  Getting Started with Application Platform Development
      • Opening the Application Platform Perspective
      • Adding a Server Runtime Environment
      •  Creating a Server Definition
        • Creating an Integration Server Definition
      •  Configuring a Server for Publishing Bundles
        • Verifying That Software AG Runtime Is Available
      •  Performing Optional Configurations
        • Disabling Natural Language Support (NLS) Warnings in Designer
        • Enabling the OSGi Console
    •  About the Application Platform Perspective
      • Application Platform Designer Views
      •  Application Platform Context Menu
        • Creating Project Bundles
        • Creating and Customizing Bundle Tool Templates for Projects
    •  About Creating Application Platform Projects
      • Selecting Project Facets
      • Selecting an Application Platform Runtime Environment
      •  Creating Java Projects
        • Folder Structure of Java Projects
      •  Creating Web Projects
        • Folder Structure of Web Projects
      • Creating a Dynamic Web Project for Integration Server
      •  Classpath Containers
        • Configuring the Application Platform API Libraries Container
        • Adding Libraries to the Application Platform API Libraries Container
        • Adding the Application Platform Shared Bundles Container
      • Bundle Tool Templates for Projects
      • Including Non-OSGi Jars in Projects
    •  Configuring a Designer Project for Application Platform
      • Configuring an Application Platform Java Project
      • Configuring an Application Platform Dynamic Web Project
    •  About Developing Web Applications for Integration Server
      • Processing Web Applications in Application Platform
      • Administering Web Applications
      • Class Loading in WmAppPlat
    • Developing Web Archive (WAR) Projects
    • Developing Web Application Bundle (WAB) Projects
    •  About Adding Single Sign-on Authentication in Application Platform Projects
      • Securing Web Application Bundle (WAB) Projects
      • Securing Web Archive (WAR) Projects
      • Securing the OSGi Service Layer
    •  About the Application Platform Integration Test Framework
      • Creating a JUnit Test for an Application Platform Project
      • Executing a JUnit Test for an Application Platform Project
    •  Managing Servers
      •  Configuring Integration Server for Application Platform Projects
        •  Configuring Launch Configuration Settings for Integration Server
          • Configuring Integration Server Arguments
          • Configuring the Integration Server Source
          • Configuring Integration Server Environment
          • Configuring Common Integration Server Settings
        • Editing the Credentials Used for Connecting to Integration Server
        • Creating a New Integration Server Instance with the Application Platform Support Package
      •  Managing Server Status
        •  Integration Server Lifecycle Actions
          • Server Start Action
          • Server Stop Action
          • Server Debug Action
          • Server Restart Action
    •  About Publishing Projects
      •  Building Projects
        • Building Projects with Designer Project Builders
        • Building Projects with Custom Application Platform Project Builders
      • Publishing Projects to the Server
      •  Manifests and Bnd Templates for Software AG Common Platform
        • Assembling Project Bundles
    •  About Viewing Dependency Graphs
      • Opening a Project in the Visual Navigator
      •  Using the Visual Navigator
        • Visual Navigator Node Depth Levels
        • Visual Navigator Context Menu Commands
        • Visual Navigator Keyboard Shortcuts
    •  About Managing Project Dependencies
      •  Bundle Publisher View
        • Publishing and Unpublishing Bundles
        •  Bundle Publisher Dependency Graphs
          • Examples of Dependency Validation
        • Refreshing the Bundle Publisher View
        • Validating Bundles
      •  Bundle Manager View
        • Creating Wrapper Bundles
        • Deleting Bundles and Jars
    •  Configuring Application Platform
      • Configuring Bundle Publisher View
      • Configuring Bundle Manager View
      • Defining Application Platform Capabilities
      • Configuring Servers View
      • Configuring Application Platform Projects
      • Developing Custom Applications
    •  About Using Services in Application Platform
      •  Service Browser View
        • Searching in the Service Browser View
        • Grouping Services by Bundle Name
        • Refreshing Services and Bundle Information
        • Filtering Services Displayed in the Service Browser View
        • Customizing Content Displayed by the Service Browser View
      •  Calling Application Platform Services from Integration Server Services
        • Coding Considerations
      •  Calling Integration Server Services from Application Platform Projects
        • Coding Considerations
      •  Generating POJO Wrappers for IS Document Types and Specifications
        • Coding Considerations
    • Application Platform Tutorial
  •  Working with Application Platform Projects
    •  About Deploying Projects
      • Configuring Asset Build Environment
      •  Configuring Application Platform Projects for Asset Build Environment
        • Application Platform Project Configuration for Asset Build Environment
      • Creating Assets with Asset Build Environment
      • Deploying Assets in Deployer
    •  About Configuring Published Projects
      • Using the Project Dynamic Configuration
  •  Administering Application Platform Using Command Central
    • Managing Application Platform Projects Using Command Central
    • Monitoring KPI Data for WAR Projects Using Command Central
  •  Diagnostics and Troubleshooting
    • Useful Logs for Application Platform
    • Increasing Tomcat Debug Logging
    • Using Log4j in WAR projects
    • JSP Validation in WmAppPlat
    • Diagnosing Bundles with the OSGi Console
    • Considerations When Publishing Projects to Servers
    •  Common Project Issues
      • Unable to Add a Project to the Server
      • Unable to Create a Bundle
      • References to Local Resources
      • Unable to Publish Any Project Bundle
      • Manually Uninstall a Bundle from the Server
      • Class Loader Issues in Published Projects
  • Differences Between WmTomcat and WmAppPlat
•  Integration Server Administrator's Guide
  • About this Guide
  •  The Role of the Administrator
    • What Does an Administrator Do?
    • Typical Administrative Responsibilities
    • The Integration Server Administrator
    • Receiving Administrative Messages from the Server
    •  The Administrator User
      • The Administrator's Password
    • Adding Backup Administrators
  •  An Overview of the Server
    •  The Role of the Server
      • About Integration Server Instances
    •  Architecture
      • Services
      • Retrieving Data for Services
    • How the Server Executes Services
    • Integration Server Security
    •  Integration Server Logging
      • Logging, Data Protection, and Privacy
    • Integration Server Caching
    • About Integration Server Fixes
  •  Starting and Stopping the Server
    •  Starting the webMethods Integration Server
      • Starting an Integration Server Instance on Windows
      • Starting Integration Server on UNIX
      • Starting a Server Instance from the Command Prompt
    •  What Happens When You Start the Server?
      • How to Tell if the Server Is Running Correctly
    •  Running Integration Server as a Windows Application vs. a Windows Service
      • Switching the Server from a Windows Service to a Windows Application
      • Switching the Server from a Windows Application to a Windows Service
    • Increasing File Descriptors on Mac OS X or Other UNIX System
    • Changing Settings in the Configuration File custom_wrapper.conf
    • Passing Java System Properties to Integration Server
    •  Shutting Down the Integration Server
      • Shutting Down the Integration Server from Integration Server Administrator
      • Shutting Down Integration Server from Windows
      • Shutting Down Integration Server from the Command Prompt
    • Viewing Active Sessions
    • Killing Sessions
    • Viewing the Integration Server Process ID
    • Restarting the Integration Server
    •  Server Recovery
      • Unapplied Changes to Integration Server Configuration Files
      •  Integration Server Data Integrity and Recoverability Considerations
        • Critical Integration Server Data Files
    •  The Java Service Wrapper
      • The Java Service Wrapper Configuration Files
      • JVM Configuration
      •  The Wrapper Log
        • Logging Properties
      • Fault Monitoring
      • Generating a Thread Dump
  •  Running Multiple Integration Server Instances
    • Overview of Integration Server Instances
    • Guidelines for Running Multiple Integration Server Instances on the Same Machine
    • About Creating a New Integration Server Instance
    •  About the is_instance Script
      • Syntax
      • is_instance Script Commands
    • Creating a New Integration Server Instance
    • Updating an Integration Server Instance
    • Updating Packages on a Server Instance
    • Updating Database Properties of a Server Instance
    • Deleting Packages from a Server Instance
    • Updating Language Packs on a Server Instance
    • Deleting a Server Instance
  •  Using the Integration Server Administrator
    • What Is the Integration Server Administrator?
    • Starting the Integration Server Administrator
    • Starting Integration Server Administrator on Windows
    • Accessing Integration Server Administrator through My webMethods
    •  Basic Operations of Integration Server Administrator
      • Logging Off Integration Server Administrator
      • Getting Help
    • The Server Configuration File
    • Software AG Command Central
  •  Introduction to the New webMethods Integration Server Administrator
    • Accessing the New Integration Server Administrator
    • First Look at the New Integration Server Administrator
    •  Dashboard
      • Overview
      • JVM Metrics
      • Usages
      •  Services
        • Service Instances
        • Cache and Prefetch Information
        • Circuit Breaker Information
      • APIs
    • Common Directory Services
    • Monitoring
    • Naming and Navigation Changes in the New Integration Server Administrator
  •  Managing Users and Groups
    •  Users and Groups
      • Purpose of Users and Groups
    •  Defining a User Account
      • Predefined User Accounts
      • Adding User Accounts
      • Deleting User Accounts
      • Adding an Administrator User
      • Adding a Developer User
      • Changing Passwords
      •  Configuring Password Requirements and Expiration Settings
        • Setting Password Requirements
        • Setting Password Expiration Requirements
        •  Configuring Account Locking Settings
          • Unlocking User Accounts
    •  Disabling and Enabling User Accounts
      • Disabling a User Account
      • Enabling a User Account
    •  Defining Groups
      • Predefined Groups
      • Adding Groups
      • Adding Users to a Group
      • Removing Users from a Group
      • Viewing Group Membership
      • Removing Groups
  •  Configuring the Server
    •  Viewing and Changing Licensing Information
      •  The License Key
        • Viewing Licensing Information
        • Changing Licensing Information
        • Renewal Reminders
        • Renewing a Key
        • Adding Licensed Features
      •  Licensed Sessions
        • Viewing Active Sessions
    • Managing the Server Thread Pool
    •  Managing Server Sessions
      • Setting the Session Timeout Limit
      • Setting the Stateful Session Limit
    •  Configuring Outbound HTTP Settings
      • Specifying Outbound HTTP Settings
    •  Setting Up Aliases for Remote Integration Servers
      • Adding an Alias for a Remote Integration Server
      • Testing the Connection to a Remote Server
      • Editing an Alias
      • Deleting an Alias
    •  Specifying Third-Party Proxy Servers for Outbound Requests
      • How Integration Server Uses Proxy Servers
      • Creating a Proxy Server Alias
      • Editing a Proxy Server Alias
      • Disabling a Proxy Server Alias
      • Enabling a Proxy Server Alias
      • Specifying a Default Proxy Server Alias
      • Deleting a Proxy Server Alias
      • Bypassing a Proxy Server
    • Configuring Where the Integration Server Writes Logging, Status, and Other Information
    • Switching from the Embedded Database to an External RDBMS
    • Working with Extended Configuration Settings
    • Specifying Character Encoding
    • Configuring the JVM
    • Specifying the JDK or JRE for Integration Server
    • Changing the JVM Heap Size Used by Integration Server
    •  Publishing and Retracting Information about Integration Server Assets
      • Configuring Integration Server to Connect to CentraSite
      • Testing the Connection to CentraSite
    • Setting a Port for Remote Client JMX Monitoring
    • Configuring Integration Server to Accept a Debug Connection During Startup
    •  Using CORS with Integration Server
      • How Integration Server Handles CORS Requests
      • Configuring Integration Server to Accept CORS Requests
  •  Connecting Integration Server to Database Components in an External RDBMS
    • Concepts
    • Pointing Functions at Connection Pools
    • Installing the MySQL Community Edition Database Driver
    • Installing the Tibero JDBC Driver
    • Creating a Driver Alias Definition
    • Creating a Connection Pool
    •  Using Kerberos Authentication for Outbound Connections to a Database
      • Using the Kerberos Re-Authentication Feature
      • Using a Different Kerberos Ticket Cache File with each JDBC Connection Pool
  •  Configuring Ports
    •  About Ports
      • Available Port Types
      • Default Ports
      • About the Port Alias
      • Package Associations for Ports
    •  Considerations for Adding Ports
      • Reasons to Add Additional Ports
      •  Considerations for Configuring Ports
        • AS/400 Considerations
        • Bind Addresses
        • Prerequisites to Configuring a Port for SSL
        • Port Usage and Security
    •  Adding an HTTP Port
      •  Advanced Controls for HTTP Ports
        • Editing Advanced Controls
    • Adding an HTTPS Port
    •  About File Polling Ports
      • Adding a File Polling Port
    •  Adding an FTPS Port
      • How Client Authentication Works for FTPS Ports
    • Adding an FTP Port
    •  Adding an E-Mail Port
      • Security Considerations for E-Mail Ports
    • Adding an HTTP Diagnostic Port
    • Adding an HTTPS Diagnostic Port
    • Suspending an HTTP/HTTPS Port
    • Resuming an HTTP/HTTPS Port
    • Testing for HTTPS Requests
    •  Using an FTP/FTPS Port Range
      • Specifying an FTP/FTPS Port Range
    •  About the Primary Port
      • Changing the Primary Port
    • Deleting a Port
    • Editing a Port
    •  About Enabling/Disabling a Port
      • Disabling a Port
      • Enabling a Port
    • Configuring How Ports Handle Client Certificates
    • Adding a Security Provider
    • Disabling Protocols for JSSE per Port
    • Designating an HTTP/S Port as Stateless
  •  Setting Up the Server Log
    • Overview of the Server Log
    •  Specifying Amount and Type of Information to Include in the Server Log
      • Logging Levels
    • Specifying Whether to Queue Server Log Entries
    • Changing the Default Server Log Location
    • Configuring the Server Log to Rotate Based on Size
    • Limiting the Number of Server Log Files Kept by Integration Server
    • Sending Messages About Critical Issues to E-mail Addresses
    • Performing Additional Processing on Log Entries
    •  Viewing the Server Log
      • Using an Alternative Server Log Entry Format
    •  Changing the Log Displays
      • Specifying the Date and Time Format to Use in Log Entries
      • Displaying Logged Data in Different Languages
      • Changing the Display Permanently for All Logs
      • Changing the Display Temporarily for the Server Log
    • Overriding Logging Level and Server Log Location for a Session
    • Globalization and the Server Log
  •  The Statistics Log
    • About the Statistics Log
    • Viewing the Statistics Log
    • Server Configuration Parameters that Affect the Statistics Log
  •  Configuring Integration Server for webMethods Messaging
    • Overview of webMethods Messaging
    •  Working with Messaging Connection Aliases
      • Predefined Messaging Connection Aliases
      • Creating a Broker Connection Alias
      •  Creating a Universal Messaging Connection Alias
        • About Follow the Master for webMethods Messaging
      • Editing a Messaging Connection Alias
      • Enabling a Messaging Connection Alias
      •  About Disabling a Message Connection Alias
        • Disabling a Messaging Connection Alias
      • Messaging Connection Alias Status
      • Specifying the Default Messaging Connection Alias
      • Deleting a Messaging Connection Alias
    • Authenticating Connections to the Universal Messaging Server
    •  Specifying the Keep-Alive Mode for the Broker Connection
      • Setting Server Configuration Parameters for Keep-Alive Mode
      • Normal Mode
      • Listen Only Mode
      • Disabled
    • Synchronizing Broker Clients When the Primary Port for Integration Server Changes
    •  Configuring Document Stores
      • Configuring the Default Document Store
      •  About the Trigger Document Store
        • Configuring the Trigger Document Store
      • Maintaining Inbound Document History for Received Documents
      • Enabling Inbound Client-Side Queuing
      •  About the Outbound Document Store
        • Configuring the Rate at which Integration Server Drains the Outbound Document Store
        • Setting the Capacity of the Outbound Document Store
      •  Associating a User Account with webMethods Messaging Trigger Services
        • Specifying a User Account for Invoking webMethods Messaging Trigger Services
    •  Load Balancing with a Non-Clustered Group of Integration Servers
      • Important Considerations for Using a Stateless Cluster with webMethods Messaging
  •  Configuring Integration Server for JMS Messaging
    • Overview of JMS Messaging Configuration
    •  Working with JNDI Providers
      • Predefined JNDI Provider Aliases
      • Creating a JNDI Provider Alias
      • Editing a JNDI Provider Alias
      • Deleting a JNDI Provider Alias
      • Creating a JNDI Provider Failover List
      • Performing a Test Lookup for a JNDI Provider
      • JNDI Provider Cache and Timeout Behavior for Administered Objects
    •  Working with JMS Connection Aliases
      • Connecting to webMethods Broker with the Native webMethods API
      • Predefined JMS Connection Aliases
      •  Creating a JMS Connection Alias
        • Allowing Destinations to Be Managed through the JMS Connection Alias and Designer
        •  Allowing Multiple Connections for a JMS Connection Alias
          • About the Connection Client ID
        • Creating a Dedicated Listener for Receiving Replies
        • Configuring Producer Caching for Sending JMS Messages
        •  Configuring Automatic Retry when Sending JMS Messages Using the pub.jms:send Service
          • About Retrying the pub.jms:send Service when Software AG Universal Messaging Is the JMS Provider
      • Editing a JMS Connection Alias
      • Enabling and Disabling a JMS Connection Alias
      • Deleting a JMS Connection Alias
      • Specifying a Connection Monitoring Period
      • Specifying a Retry Interval for Failed Connections
      • Specifying a Keep-Alive Interval
    • Creating Administered Objects
    •  Monitoring a Connection Factory Object for Changes
      • Polling for Changes
      • Registering an Event Listener
      • How Integration Server Updates the Connection
      • Configuring Integration Server to Monitor a Connection Factory Object
    • Using SSL with JMS
    •  Supported JMS Providers
      • Considerations for JMS Providers
      • About Using Software AG Universal Messaging as the JMS Provider
    • Adding JMS Provider Client Libraries to Integration Server Classpath
  •  Configuring Integration Server for MQTT Messaging
    •  Overview of MQTT Support in Integration Server
      • Limitations of MQTT Support in Integration Server
    • Supported MQTT Servers
    • Creating an MQTT Connection Alias
    • Editing an MQTT Connection Alias
    • Enabling and Disabling an MQTT Connection Alias
    • Deleting an MQTT Connection Alias
    • Specifying a Retry Interval for Failed Connections to the MQTT Server
  •  Using Enhanced Logging for Messaging
    • About Enhanced Logging for Messaging
    •  What Is in Log Entries for Enhanced Logging?
      • Logging Levels for Enhanced Messaging Logging
    • Using the Messaging Log or the Server Log for Enhanced Logging
    • Configuring Enhanced Logging for Messaging
    • Viewing the Messaging Log
  •  Setting Up Universal Messaging Client Logging
    • Universal Messaging Client Logging
    • Configuring Universal Messaging Client Logging
    • View the Universal Messaging Client Log
  •  Configuring Endpoint Aliases for Web Services
    • About Web Service Endpoint Aliases
    •  Creating an Endpoint Alias for a Provider Web Service Descriptor for Use with HTTP/S
      • Setting a Default Endpoint Alias for Provider Web Service Descriptors
    • Creating an Endpoint Alias for a Consumer Web Service Descriptor for Use with HTTP/S
    • Creating an Endpoint Alias for Message Addressing for Use with HTTP/S
    • Creating an Endpoint Alias for a Provider Web Service Descriptor for Use with JMS
    • Creating an Endpoint Alias for a Consumer Web Service Descriptor for Use with JMS
    • Creating an Endpoint Alias for Message Addressing for Use with JMS
    • Timestamps in the WS-Security Header
  •  Configuring Reliable Messaging in Integration Server
    •  Overview of Reliable Messaging
      • Understanding Reliable Messaging Terminology
    •  Using Reliable Messaging in Integration Server
      • Persistent Storage Support for Reliable Messaging Data
      • Limitations When Using Reliable Messaging in Integration Server
    • Configuring Reliable Messaging in Integration Server
    •  Reliable Messaging Sequence Reports
      • Client and Server Sequences
      • Viewing Reliable Messaging Sequence Reports
    • Closing a Sequence
    • Terminating a Sequence
    • Sending an Acknowledgement Request
  •  Configuring Integration Server to Use JWT
    • Overview of JWT
    • Using JWT with Integration Server
    • Support for JWT in Integration Server
    •  Configuring Integration Server to use JWT
      •  Trusted Issuers
        • Adding Trusted Issuers
        • Deleting a Trusted Issuer
      •  Issuer-Certificate Mapping
        • Creating an Issuer-Certificate Mapping
        • Deleting an Issuer Certificate Mapping
      •  Skew Mapping
        • Creating an Issuer Skew Mapping
      • Editing Global Claim Settings
  •  Configuring Integration Server to Use Kerberos
    • Overview of Kerberos Usage in Integration Server
    •  About Kerberos
      • Kerberos Terminology
    • Kerberos Delegated Authentication
    • Prerequisites to Configuring Kerberos
    • Limitations When Using Kerberos Authentication in Integration Server
    •  Configuring Integration Server to Use Kerberos
      • Order of Precedence for Principal Name and Password
    • JAAS Contexts for Kerberos
    • Troubleshooting Kerberos Configuration
  •  Setting Up HTTP URL Aliases
    • Overview
    •  Creating an HTTP URL Alias
      • Specifying the URL Path
      •  Using Port Mappings with a URL Alias
        • Adding a Port Mapping to a URL Alias
        • Deleting a Port Mapping for a URL Alias
      •  Using a URL Alias for the “Empty Path”
        • Creating a URL Alias for the Empty Path
    • Enabling Partial Matching of URL Aliases
    •  Displaying HTTP URL Aliases
      • About HTTP URL Alias Association
    • Editing a URL Alias
    • Deleting a URL Alias
    • Portability of URL Aliases and Possible Conflicts
  •  Using HTTP Interceptors
    •  Overview of HTTP Interceptors
      • Types of HTTP Interceptors
      • HTTP Interceptor Interfaces
      • Working of HTTP Interceptors
    • Considerations for Creating an HTTP Interceptor
    • Creating an HTTP Interceptor
  •  Configuring Integration Server for HTTP Compression
    • Overview
    • HTTP Request Compression
    • HTTP Response Compression
  •  Configuring Integration Server to Connect to an SFTP Server
    • Overview of SFTP
    •  Creating an SFTP Server Alias
      • Editing an SFTP Server Alias
    •  Creating an SFTP User Alias
      • Editing an SFTP User Alias
      • Migration Impact on SFTP Configurations
      • Testing the Connection to the SFTP Server
  •  Configuring Integration Server for Secure Communications
    •  Overview of SSL in Integration Server
      • Supported SSL Authentication Types
    •  Supported SSL/TLS Protocols
      • TLSv1.3 Support
      • Changes to watt.net.jsse* Parameters for Default Disabled Protocols
      • Disabling TLS Renegotiation
    • Specifying Cipher Suites for Use with SSL
    •  Preparing to Configure SSL in Integration Server
      • Creating Public/Private Keys and Certificates for Integration Server
      • Creating a Keystore and Truststore
      • Obtaining the Public Keys and Certificates of the Partner Application or Resource
      •  Configuring Integration Server SSL Keys and Certificates
        • Specifying Integration Server SSL Certificates and Keys
    •  Usage of CA Certificates: Technical Considerations
      • Handling Expired CA Certificates
      • Customizing Usage of Truststores
    •  Configuring Integration Server as an SSL Server
      •  Configuring an HTTPS or FTPS Port
        • Controlling Server SSL Security Level by Port
    • Configuring Integration Server as an SSL Client
    •  Configuring SSL Information for the Integration Server JVM
      • Order of Precedence for the javax.net.ssl Properties
    •  Using Multiple Client Certificates with SSL Servers
      • Setting Up a Remote Server Alias
      • Coding Your Flow Services
    • WS-Security and Integration Server
  •  Setting Up SSL Session Logging
    • Overview of the SSL Session Log
    • Enabling the SSL Session Logging
    • Viewing the SSL Session Log
    • Changing the Default SSL Session Log Location
    • Managing the SSL Session Log Size
    • Avoiding Duplicate Entries in the Log
  •  Using Keystores and Truststores with Integration Server
    •  Keystores and Truststores
      •  Keystore File
        • Keystore File Formats
        • HSM-Based Keystores
        • Creating a Keystore
      •  Truststore File
        • Truststore File Formats
    •  How Integration Server Uses a Keystore and Truststore
      • Protecting Keystore and Truststore Files
    •  Keystore, Truststore, and Key Aliases
      • Default Keystore and Truststore Aliases
      • Creating Keystore Aliases
      • Creating Truststore Aliases
  •  Controlling Access to Resources
    • Overview
    •  Controlling Access to Resources by Port
      •  Restricting IP Addresses that Can Connect to a Port
        •  Controlling IP Access to All Ports (Globally)
          • Allow Inbound Connections from Specified Hosts (Deny All Others)
          • Deny Inbound Connections from Specified Hosts (Allow All Others)
        • Allow Inbound Requests from Specified Hosts (Deny All Others)
        • Deny Inbound Requests from Specified Hosts (Allow All Others)
        •  If You Inadvertently Deny IP Access to All Hosts
          • Resetting the Global Setting IP Access Setting
          • Resetting the IP Access Setting for an Individual Port
      •  Restricting the Services or Web Service Descriptors Available from a Port
        • Allow Access to Specified Services (Deny All Others)
        •  Deny Access to Specified Services (Allow All Others)
          • Resetting a Port to the Default Access
    • Controlling the Use of Directives
    •  Controlling Access to Resources with ACLs
      •  About ACLs
        • Package Replication
        • Implicit and Explicit Protection
        • Users that Belong to More than One Group
      • Predefined ACLs
      • When Does the Server Perform ACL Checking?
      • Creating ACLs
      • Allowing or Denying Group Access to ACLs
      • Deleting ACLs
      •  Default Settings and Inheritance
        • What Happens When You Change Existing ACL Assignments
      • Assigning ACLs to Folders, Services, and Other Elements
      • Removing an ACL from a Folder or Service
      •  Assigning ACLs to Files the Server Can Serve
        • Rules for Using .access Files
      • Removing ACL Protection from a File
    •  Adding Services to a Blacklist
      • Using a File for the Service Blacklist
  •  Authenticating Clients
    • Overview
    • Basic Authentication
    • Digest Authentication
    • Kerberos Authentication
    •  Client Certificate Authentication
      •  Certificate Mapping
        • Importing a Client Certificate and Mapping It to a User
        • Changing a Certificate Mapping
      • Client Certificates and Port Configuration
    • Client Authentication and Access Control
    •  Single Sign-On Authentication for My webMethods
      • Configuring the MWS Single Sign-On Resource Setting
    •  SAML Authentication
      • Requirements for SAML Authentication
      • Identifying Trusted STSs to Integration Server
      • Accepting SAML2 Tokens at the Transport Level
  •  Customizing Authentication Using JAAS
    • Overview
    • Using JAAS with Integration Server
    •  JAAS Configuration File
      • Pre-installed Login Modules
      • X509ValidatorModule
    • Pluggable Authentication Modules (PAMs)
    •  Writing a Custom JAAS Login Module for Integration Server
      • Extend SagAbstractLoginModule
      • Implement Commit()
      • Place the JAR File in the Integration Server Classpath
      • Modify the JAAS Configuration File
    •  JAAS Custom Login Module Example
      • JAAS Login Module for Integration Server: Sample Code
      • JAAS Custom Login Module: Code Explanation
      • JAAS Configuration File: Sample Module
  •  Master Passwords and Outbound Passwords
    • Overview
    • Managing Outbound Passwords
    • Backing Up Outbound Password and Master Password Files
    • Changing the Master Password
    • Changing the Expiration Interval for the Master Password
    • About the configPassman.cnf File
    •  Working with Outbound Password Settings
      • Controlling Name and Location of Outbound Password File
      • Controlling Encryption of Outbound Password File
    •  Working with Master Password Settings
      • Storing the Master Password in a File
      • Prompting for the Master Password at Server Initialization
    • What to Do if You Lose or Forget Your Master Password
    •  When Problems Exist with the Master Password or Outbound Passwords at Startup
      • Determining Whether You Can Restore the Passwords
      • Restoring the Master Password and Outbound Password Files
      • Resetting the Master Password and Outbound Passwords
    • E-mail Listeners and Package Replication
  •  Securing Integration Server with CSRF Guard
    • What is CSRF?
    • How Does Integration Server Prevent CSRF Attacks?
    • Understanding CSRF Guard Terminology
    • Configuring CSRF Guard in Integration Server
    • Limitations when Configuring CSRF Guard in Integration Server
  •  Configuring webMethods Enterprise Gateway
    • Overview
    •  How Enterprise Gateway Works
      • Enterprise Gateway Ports
      •  Enterprise Gateway Rules and Alerts
        • About Enterprise Gateway Rules
        • About Enterprise Gateway Alerts
    • Version Interoperability Between Enterprise Gateway Server and Internal Server
    • Advantages of Enterprise Gateway over Traditional Third-Party Proxy Servers
    •  About Denial of Service Protection
      • About Trusted IP Addresses
    • About Mobile Application Protection
    • About Mobile Data Synchronization
    • About SQL Injection Protection
    • About Antivirus Scan Filter
    • About Custom Filter
    • Clustering in the Enterprise Gateway Configuration
    • Setting Up an Enterprise Gateway
    •  Configuring the Enterprise Gateway Ports
      • Deleting Enterprise Gateway External and Registration Ports
    • Connecting Your Internal Server to an Enterprise Gateway Server
    • Viewing Connections to the Enterprise Gateway Registration Port
    • Performing Client Authentication on Enterprise Gateway Server
    •  Working with Enterprise Gateway Rules
      • Creating an Enterprise Gateway Rule
      • Enabling an Enterprise Gateway Rule
      • Disabling an Enterprise Gateway Rule
      • Editing an Enterprise Gateway Rule
      • Copying an Enterprise Gateway Rule
      • Changing the Priority of an Enterprise Gateway Rule
      • Deleting an Enterprise Gateway Rule
    •  Specifying Alert Options
      • Specifying Default Alert Options
      • Specifying Rule-Specific Alert Options
    •  Preventing Denial of Service Attacks
      • Limiting Requests Globally
      • Limiting Requests by IP Address
    • Controlling Use of Mobile Applications
    • Frequently Asked Questions about Enterprise Gateway
  •  Configuring OAuth
    • What Is OAuth?
    •  Using OAuth with Integration Server
      • Integration Server as an OAuth Client
      •  Integration Server as an Authorization Server
        • Integration Server as an External Authorization Server
      • Integration Server as a Resource Server
    • OAuth Client Types
    •  Authorization Grant Types Supported by Integration Server
      • Authorization Code Grant
      • Implicit Grant
      • Resource Owner Password Credentials Grant
      • Client Credentials Grant
    • The Integration Server OAuth Services
    • Important Considerations for Using OAuth Features
    •  Configuring Integration Server for OAuth
      • Configuring OAuth Settings
      •  Defining Clients
        • Registering Clients
        • Enabling and Disabling Clients
        • Editing Clients
        • Deleting Clients
      •  Defining Scopes
        • Adding a Scope
        • Editing Scopes
        • Deleting Scopes
      •  Associating Scopes and Clients
        • Adding Associations Between Clients and Scopes
        • Removing Client and Scope Associations
        • Viewing Associations Between Clients and Scopes
      •  Managing Tokens
        • Viewing Tokens
        • Deleting Tokens
        • Revoking Tokens
        • Removing Expired Access Tokens
      • Customizing the Approval Page
    • About Using Integration Server as the Resource Server
    •  Using an External Authorization Server
      • Creating an External Authorization Server Alias
      • Deleting an External Authorization Server
  •  Configuring a Central User Directory or LDAP
    • Before You Begin
    •  Overview of How Integration Server Works with Externally Defined Users and Groups
      • How the Server Uses Externally Defined Users and Groups
      • When the Server Accesses Externally Defined Information
      • How Integration Server Authenticates Externally Defined Clients
    •  Configuring Central User Management
      • Requirements for Integration Server to Use Central User Management
      • Considerations for My webMethods Server Query Roles
    •  Overview of Using LDAP
      • About LDAP and Caching
    •  Configuring the Server to Use LDAP
      • Defining an LDAP Directory to Integration Server
      • Mapping an LDAP User's Access to ACLs
      • Stopping Use of an LDAP as an External Directory
    •  Considerations for User Accounts and Groups
      • About Keeping Internal and External User Accounts and Group Names Unique
      • About User Groups and Package Replication
    •  About Granting Administrator Privileges to External Users
      • Granting Administrator Privileges to an Externally Defined User
    • Granting Developer Privileges to External Users
    • Granting Access to Services and Files to External Users
  •  Managing Packages
    •  Using Packages
      • Predefined Packages
      • The Package Repository
      • Sample Package
    •  How the Server Stores Package Information
      • Manifest File
    •  Finding Information about Your Packages
      •  Viewing the Packages that Reside on Your Server
        • Filtering the List of Packages
        • Refining the Filtered Package List
        • Determining Whether the Server Successfully Loaded the Package
        • Determining Whether the Package Is Enabled or Disabled
      •  Displaying Information about a Package
        • Package Information
      • Displaying Information about Services and Folders in a Package
      •  Displaying Documentation for a Package
        • Accessing a Web Document for a Package
    •  Working with Packages
      • Creating a Package
      • Activating a Package
      • Reloading a Package
      • Enabling a Package
      • Disabling a Package
      • Deleting a Package
      • Recovering a Package
      • Archiving a Package
    •  Copying Packages from One Server to Another
      • Overview of Package Replication
      •  Version Checking
        • Who Can Subscribe?
        • Guidelines for Using Package Replication
      •  The Publishing Server
        • Displaying Subscribers for a Specific Package
        • Displaying Subscribers for all Packages
        • Adding Subscribers from a Publishing Server
        • Updating Subscriber Information
        • Removing Subscribers for a Package
        •  Publishing a Package
          • Creating a Release
          • Sending a Release
      • Specifying File and Version Information for a Release or Archive
      •  The Subscribing Server
        • Displaying Packages to Which Your Server Subscribes
        • Manually Pulling a Package
        •  Subscribing to a Package from a Subscribing Server
          • Requesting a Subscription to a Package from Another Server
        • Updating Your Subscription Information
        • Canceling a Subscription
        •  About Installing Packages Published by Another Server
          • Installing a Package Published by Another Server
    • Using a Package Class Loader
    •  Hot Deployment of Packages
      •  How Hot Deployment Works
        • Determining Package Dependencies during Hot Deployment
      • Considerations for Hot Deployment of Packages
      • Enabling and Configuring Hot Deployment of Custom Packages
      • Disabling Hot Deployment of Custom Packages
    • Automatic Package Deployment
  •  Managing Services
    • About Services
    •  Fully Qualified Service Names
      • Package Names and Service Names
      • HTTP URL Aliases for Services
    •  Finding Information about Services and Folders
      • Listing Folders and Services
      •  Displaying Information about a Service
        • Service Information
    • Manually Adding a Service to the Server
    • Testing Services
    •  Canceling and Killing Threads Associated with a Service
      • Canceling or Killing a Thread
    •  Running Services When Packages Are Loaded, Unloaded, or Replicated
      • What Is a Startup Service?
      • What Is a Shutdown Service?
      • What Is a Replication Service?
      • Guidelines for Using Startup, Shutdown, and Replication Services
    • Running Services in Response to Specific Events
    •  Managing Global Variables
      • Creating a Global Variable
      • Deleting Global Variables
  •  Scheduling Services
    •  Overview
      • Tasks Provided by Integration Server
    • Scheduling a User Task
    •  Viewing Scheduled User Tasks
      • Filtering the List of Scheduled Tasks
    • Updating Scheduled User Tasks
    •  Suspending User Tasks
      • Suspending a Single User Task
      • Suspending All User Tasks
    •  Resuming Suspended User Tasks
      • Resuming a Suspended User Task
      • Resuming All Suspended User Tasks
    • Canceling a Scheduled User Task
    • Viewing the Scheduled System Tasks
    • Simple Repeating Option
    • Complex Repeating Option
    •  Target Node Options
      • Tasks in a Clustered Environment
    • How Transitioning to or from Daylight Savings Time Affects Scheduled Tasks
  •  Caching Service Results
    • What Is Caching?
    • When Are Cached Results Returned?
    • Using a Public Cache for Service Results Caching
    •  Resetting the Cache
      • Resetting the Cache for All Services
      • Resetting the Cache for a Specific Service
    • Monitoring Service Cache Usage
    • Viewing Service Results in a Public Cache
  •  Configuring Guaranteed Delivery
    • About Guaranteed Delivery
    •  Configuring the Server for Guaranteed Delivery
      • Settings Shared by Both Inbound and Outbound Transactions
      • Settings for Inbound Transactions
      • Settings for Outbound Transactions
      • Specifying an E-Mail Address and SMTP Server for Error Messages
      • Using Guaranteed Delivery with Multiple Servers that Share an ISInternal Database
    •  Administering Guaranteed Delivery
      • Shutting Down Guaranteed Delivery
      •  Reinitializing Guaranteed Delivery
        • Reinitializing Guaranteed Delivery for Inbound Transactions
        • Reinitializing Guaranteed Delivery for Outbound Transactions
  •  Configuring Ehcache on Integration Server
    • What is Ehcache?
    •  Caching Configurations
      • On-Heap Cache
      • Local Disk Store
      • BigMemory
      • Terracotta Server Array
    •  Understanding Caches and Cache Managers
      • System Caches
    •  Cache Manager Configuration Files
      •  Specifying the Parameters for a Cache
        • Dynamic vs. Non-Dynamic Cache Parameters
    •  Installing, Viewing, and Changing the Terracotta License
      • Determining if You Have a Terracotta License
      • Adding a Terracotta License
    •  Configuring an On-Heap Cache
      • Considerations for Configuring On-Heap Cache
    •  Configuring a BigMemory Cache
      • Allocating Direct Memory Space to Integration Server
      • Considerations for Configuring BigMemoryCache
    •  Configuring a Distributed Cache
      • Configuring tc-config.xml on the Terracotta Server Array
      • Considerations for Configuring a Distributed Cache
      •  Cache-Wide and Client-Specific Parameters for a Distributed Cache
        • Cache-Wide Parameters
        • Client-Specific Parameters
      • The Rejoin Behavior of a Distributed Cache
      • The Nonstop Behavior of a Distributed Cache
      • About the Maximum Entries in Cache Value
    •  Making a Cache Searchable
      •  Defining Attributes
        •  Extracting Attributes by Class
          • Example Extractor
    •  Working with Cache Managers
      • Creating a Cache Manager
      • Viewing or Modifying a Cache Manager
      • Shutting Down a Cache Manager
      • Starting a Cache Manager
      • Reloading a Cache Manager
      • Deleting a Cache Manager
      • Reinitializing a Cache Manager
      • Adding a Cache Manager Configuration File to Integration Server
      • Manually Editing a Cache Manager Configuration File
    •  Working with Caches
      • Creating a Cache
      • Viewing or Modifying Cache Settings
      • Modifying Settings for a Distributed Cache
      • Disabling a Cache
      • Enabling a Cache
      • Clearing a Cache
      • Deleting a Cache
    •  Logging Ehcache Activity
      • Logging Ehcache Caching Services
      • Logging Cache Manager Activity in the Terracotta Server Array
  •  Configuring the Enhanced XML Parser
    • What Is the Enhanced XML Parser?
    • How Does the Enhanced XML Parser Work?
    •  When Is the Enhanced XML Parser Used?
      • What Services Consume an Enhanced Node?
    • Configuring the Enhanced XML Parser
    • Setting the Partition Size
    • Viewing Peak Usage Statistics
  •  Configuring WebSockets
    • Overview
    • How WebSocket Works
    • Setting Up Integration Server for WebSockets
    • Configuring a WebSocket Ports
    • Configuring a WebSocketSecure Ports
    • Viewing WebSocket Server Endpoints for a WebSocket Port
    • WebSocket Server Sessions Page
    • Limitations When Using WebSocket Protocol in Integration Server
  •  Locking Administration and Best Practices
    • Introduction
    • Choosing Local Server Locking or VCS Integration Locking
    •  Disabling and Re-enabling Locking
      • Disabling Locking
      • Re-Enabling Locking
    •  Best Practices
      • Remote Server Configuration
      • Server User Names
      • Package Replication and Publishing
      • Package and Folder Organization
      • Source Code
      • Upgrading webMethods Integration Server
  •  Managing webMethods Messaging Triggers
    • Introduction
    •  Managing Document Retrieval
      •  Increasing or Decreasing Threads for Document Retrieval from webMethods Broker
        • When to Increase or Decrease Threads for Retrieving Documents from webMethods Broker
      •  Decreasing the Capacity of Trigger Queues
        • Decreasing the Capacity and Refill Level for webMethods Messaging Triggers
      •  Suspending and Resuming Document Retrieval
        •  About Suspending and Resuming Document Retrieval for All Triggers
          • Suspending or Resuming Document Retrieval for All webMethods Messaging Triggers
        •  About Suspending and Resuming Document Retrieval for a Specific Trigger
          • Suspending or Resuming Document Retrieval for a webMethods Messaging Trigger
    •  Managing Document Processing
      •  Increasing or Decreasing Threads for Processing Documents Received by webMethods Messaging Triggers
        • When to Increase or Decrease Threads for Processing Documents
      •  Decreasing Document Processing for Concurrent Triggers
        • Decreasing Execution Threads for Concurrent webMethods Messaging Triggers
      •  Suspending and Resuming Document Processing
        •  About Suspending and Resuming Document Processing for all Triggers
          • Suspending or Resuming Document Processing for All webMethods Messaging Triggers
        •  About Suspending and Resuming Document Processing for Specific Triggers
          • Suspending or Resuming Document Processing for a Specific webMethods Messaging Trigger
    •  Limiting Server Threads for webMethods Messaging Triggers
      • Setting the Maximum Number of Server Threads for webMethods Messaging Triggers
    •  Cluster Synchronization for webMethods Messaging Trigger Management
      • Configuring Cluster Synchronization
      • Cluster Synchronization at Run Time
      • Monitoring Cluster Synchronization
    • Modifying webMethods Messaging Trigger Properties
    • Managing Trigger Service Retries and Shutdown Requests
    •  Delaying Polling Requests for webMethods Messaging Triggers
      • How Integration Server Delays a Polling Request for a webMethods Messaging Trigger
    •  Serial Triggers Migrated to Integration Server 10.3 or Later from Earlier Versions
      • Synchronizing the webMethods Messaging Trigger and Durable Subscription on Universal Messaging
  •  Managing JMS Triggers
    • Introduction to JMS Trigger Management
    • Searching for JMS Triggers
    •  About JMS Trigger Status and State
      • Enabling, Disabling and Suspending a JMS Trigger
      • Configuring Integration Server to Enable JMS Triggers Automatically after a Consumer Error
    •  Controlling Thread Usage for JMS Triggers
      • Viewing Thread Usage for JMS Triggers
      • Throttling Thread Usage for JMS Triggers
      • Establishing a Threshold for Using Multiple Threads with a Concurrent JMS Trigger
    • Configuring Integration Server Session Reuse
    • Configuring JMS Session Reuse
    •  Delaying Polling Requests for Concurrent JMS Triggers
      •  How JMS Trigger Delays a Polling Request
        • Examples of Extended Polling Delay Configuration
    •  What Happens When JMS Triggers Fail to Start?
      • How Does the JMS Trigger Restart Task Work?
    •  About WS Endpoint Triggers
      • Editing WS Endpoint Triggers
  •  Managing MQTT Triggers
    • Introduction to MQTT Trigger Management
    •  MQTT Trigger State and Status
      • Changing the State of an MQTT Trigger
    • Configuring Integration Server Session Reuse for MQTT Triggers
    • Automatic Retry for Starting MQTT Triggers
  •  Using a Document History Database with Exactly-Once Processing
    • Overview
    •  Removing Expired Entries from the Document History Database
      • Clearing Expired Entries from the Document History Database
    • Viewing Exactly-Once Processing Statistics
    • Clearing Exactly-Once Processing Statistics
  •  Using Integration Server to Manage XA Transactions
    •  Overview of XA Transaction Management
      • How the Integration Server Persists the State of a Transaction
      • How the Integration Server Resolves Uncompleted Transactions
      • About Unresolved XA Transactions
      • Details for an Unresolved XA Transaction
    •  Configuring XA Options in Integration Server
      • Enabling or Disabling XA Transaction Recovery
      • Configuring the XA Recovery Store
      • Configuring XA Server Parameters
    • Manually Resolving a Transaction
  •  Content Handlers in Integration Server
    • How Integration Server Uses Content Handlers
    • How Integration Server Chooses a Content Handler for an HTTP Request
    • How Integration Server Chooses a Content Handler for an FTP Request
    • Content Handlers for HTTP and FTP Requests
    •  About Content Handlers for HTTP Responses
      • Accept Header Field
    • About Content Handlers for FTP Responses
  •  Class Loading in Integration Server
    •  How Class Loading Works in Integration Server
      •  Class Loaders
        • OSGi Bundle Class Loader
        • Integration Server Class Loaders
      •  Classpaths
        •  How the Integration Server Classpath Is Set
          • Additional Information about How the Microservices Runtime Classpath Is Set
    •  Adding Classes to the Server Classpath
      • Adding Classes to a Package
      • Class Searching Order
      •  How Classes Are Found
        • How Classes Are Found in Microservices Runtime
      • Searching Order within a Package
    • Where to Put Your Classes and Jar Files
    • Accelerating Class Loading
  •  Whitelist Filtering in Integration Server
    • About Whitelist Filtering in Integration Server
    • Enabling or Disabling Whitelist Class Filtering
    • Integration Server Whitelist Classes File
    • Creating a Package Whitelist Classes File
    • Logging Classes that Are Not on the Whitelist
    • Integration Server Blacklist Classes File
  •  Quiescing the Server for Maintenance
    •  Overview
      • What Happens when Integration Server Enters Quiesce Mode?
      • What Tasks Can You Perform in Quiesce Mode?
      • What Happens when Integration Server Exits Quiesce Mode?
    • Specifying the Quiesce Port
    •  Quiescing Integration Server
      • Starting the Server in Quiesce Mode from the Command Prompt
      • Quiescing an Active Server from Integration Server Administrator
      • Restarting a Server in Quiesce Mode from Integration Server Administrator
    • Exiting Quiesce Mode
    • Deploying Quiesce Mode Configuration
  •  Diagnosing the Integration Server
    • Introduction
    •  Configuring the Diagnostic Port
      • Diagnostic Thread Pool Configuration
      • Diagnostic Port Access
    •  Using the Diagnostic Utility
      • Diagnostic Utility Performance
      • Running the Diagnostic Utility from Integration Server Administrator
      • Running the Diagnostic Utility Service
    •  Starting the Integration Server in Safe Mode
      • Starting Integration Server in Safe Mode
    • When the Server Automatically Places You in Safe Mode
    •  Generating Thread Dumps
      • Generating a Dump of an Individual Thread
      • Generating a Dump of the JVM
  •  Debugging Service Exceptions Using the Error Log
    • Introduction
    • Controlling the Level of Exception Logging Detail
    • Displaying the Error Log
    •  Interpreting the Error Log
      • Understanding the Service Stack
      • Understanding the Error Messages
      • Understanding the Stack Trace
  •  Using Integration Server with Docker
    •  Overview of Docker and Integration Server
      • Recommendations for Using Integration Server with Docker
    •  About the is_container Script
      • is_container Script Commands
    • Prerequisites for Building a Docker Image
    • Specifying Services to Expose to Consumers in webMethods Cloud
    • Building the Docker Image for an Integration Server Instance
    • Loading a Docker Image to an On-Premise Docker Registry
    • Pushing a Docker Image to an On-Premise Docker Registry
    •  Running the Docker Image in an On-Premise Docker Container
      • Writing the Server Log to the Console
      • Writing Audit Logs to the Console
      • Accessing an Integration Server Running in a Docker Container
      • Externalizing Log and Configuration Files When Running Integration Server in a Docker Container
    • Pushing the Docker Image to Integration Cloud
    • Running the Docker Image in Integration Cloud
    • Stopping a Docker Container for Integration Server
    • Using a Configuration Variables Template with a Docker Image
  •  Integration Server Administrator API
    • Introduction to the Administrator API
    • Authentication and Authorization
    • REST URL Structure
    • CRUD Operations
    • Administrative Actions
    • Credentials
    • Expanding Responses
    • Media Type for Responses
    • Media Type for Request Payloads
    • Getting Started
    •  Controlling Access to the Administrator API
      • Creating a Read-Only Administrators Group
    • Logging Client Errors
    • Including a Stack Trace in the Response Body
    • Integration Server Administrator API Operations
  •  Controlling JSON Output
    • Controlling Date Encoding in JSON Responses
    • Formatting JSON Output to Make it More Readable
  •  Using Command Central to Manage Integration Server
    • An Overview of Command Central
    •  Integration Server Instance Management
      • Creating Instances Using Command Central Web User Interface
      • Updating Instances Using Command Central Web User Interface
      • Deleting Instances Using Command Central Web User Interface
      • Managing Instances Using the Command Central Instance Management Commands
    •  Accessing Integration Server Administrator through Command Central
      • Changing the Authentication Mode
      • Changing the Administrator User Password for Integration Server in Command Central
      • Configuring Integration Server for SSL Connection
    •  Monitoring Integration Server Instances
      • Run-time Monitoring Statuses for IntegrationServer-instanceName
      • Run-time Monitoring States for IntegrationServer-instanceName
      • Monitoring KPIs of Integration Server Instances
    •  Integration Server Configuration Types
      • Configuration Types that IntegrationServer-instanceName Supports
      • Working with Integration Server Configuration Types
    • Lifecycle Actions for Integration Server
    • Commands that Integration Server Supports
    • Using Unix Shell Scripts to Change Connection Credentials for Managed Products
    • Command Central Command Line Tool Upgrade
  •  Integration Server Deployment Checklist
    • Introduction
    • Stage 1: Installation
    • Stage 2: Basic Configuration
    • Stage 3: Setting Up Users, Groups, and ACLs
    • Stage 4: Publishing Packages
    • Stage 5: Installing Run-Time Classes
    • Stage 6: Preparing Clients for Communication with the Server
    • Stage 7: Setting Up Security
    • Stage 8: Startup and Test
    • Stage 9: Archive Sources
  •  Server Configuration Parameters
    • Introduction
    • watt.adapters.
    • watt.adminapi.
    • watt.art.
    • watt.broker.
    • watt.brokerCoder.
    • watt.cachedirective.
    • watt.cds.
    • watt.config.
    • watt.core.
    • watt.debug.
    • watt.debug2.
    • watt.frag.
    • watt.infradc.
    • watt.net.
    • watt.security.
    • watt.server.
    • watt.serverlog.
    • watt.ssh.
    • watt.ssl.
    • watt.tx.
    • watt.um
    • watt.wm.tnextdc.
    • watt.wmcloud.
  •  Environment Variables
    • Environment Variables Defined in Integration Server and Microservices Runtime
  •  FIPS 140-2 Compliance
    • FIPS 140-2 Compliance
  •  Using NTLM Authentication when Integration Server Acts as the Client
    • Overview
    • Using Java-Based NTLM Support
    •  Using Native NTLM Support via Integrated Windows Authentication
      • Activating Integrated Windows Authentication
      • Deactivating Integrated Windows Authentication
  •  Removing User Data from Integration Server
    • Removing User Data
    • Removing References to a User Account
    • Removing References to Email Addresses
    •  Removing Personal Data from Log Files
      • Removing Personally Identifiable Information from the Server Log
      • Removing Personally Identifiable Information from the Session Log
      • Removing Personally Identifiable Information from the Service Log
      • Removing Personally Identifiable Information from the Security Log
      • Removing Personally Identifiable Information from the SSL Session Log
      • Removing Personally Identifiable Information from the Configuration Variables Log
      • Removing Personally Identifiable Information Logged by Axis2, Kerberos, SAML, and other Third Party Libraries
  •  Wireless Communication with the Integration Server
    • Overview
    • How Does the Integration Server Communicate with Wireless Devices?
    •  Using URLs for Wireless Access to the Integration Server
      • Invoking a Service with a URL
      • Requesting a WML or HDML Page with a URL
    • WML and HDML Samples
  • Masking Session IDs in Integration Server Session and Server Logs
  •  Server Log Facilities
    • About Server Log Facilities
    • Integration Server
    • WmJSONAPI Package
    • WmParquet Package
    • WmXSLT Package
    • Flat File
• Copyright

Building DevOps Edition for Continuous Integration

Copyright

help_refactor_guidelines

help_refactoring_elements

help_search_guidelines

help_search_elements_packagenavigator

test_flow

for_each_map

define_map_service

map_service

build_map_service

create_map_service

set_map_property

graphical_tree_tab

help_working_with_RAD_openapi

rad_createfrmopenapiprov

rad_general_openapi

rad_server_openapi

rad_resources_openapi

rad_schemas_openapi

rad_security_openapi

rad_tags_openapi

rad_source_openapi

help_generate_REST

help_RESTV2_res_opn

rad_secdefine

rad_resttags

rad_edit

rad_createfromswagger

rad_is_swagger_mapping

help_working_with_RAD

rad_createfrmswaggerconsu

help_publish_REST_API

help_configure_json_documenttype

help_graphql_create

help_graphqlDataloader_create

help_with_websocket

help_with_server_endpoint

rad_create

help_working_with_recipes

help_ffschema_create

help_configure_connection

help_connect_API-Portal

help_remove_gateway_connection

help_configure_gateway_connection

help_publish_REST_wsd

help_connect_IC

help_configure_ICconnection

help_cloud_overview_clouddep

help_cloud_deploy_asset

help_cloud_overview_assetrepo

help_cloud_open_assetrepoview

help_cloud_build_assetinrepoview

help_cloud_deploy_assetrepoview

help_cloud_del_asset

help_cloud_config_univmsg

help_cloud_landscapr_navigatorview

help_cloud_create_ccdef

help_cloud_edit_ccdef

help_cloud_del_ccdef

help_cloud_browse_runtimeconfig

help_cloud_export_depconfig

help_cloud_configproject

utf_utfperspective_open_Scrn

utf_pref_adv

utf_pref_lic

utf_pref_edi

utf_pref_val

utf.testsuite

utf_testsuite_createScrn

utf_testsuiteScrn

utf_testcase_add

utf_testdetails_viewScrn

utf_testcase_servicedetailsScrn

utf_testcase_inputScrn

utf_testcase_outputScrn

utf_testcase_outputcompareScrn

utf_generatetest_exeresultScrn

utf_mocks_useScrn

utf_exetest_executorScrn

utf_codecoverage_runScrn

utf_codecoverage_viewScrn

utf_mockevents_viewScrn

utf_codecoverage_launchScrn

help_home

help_window_preferences_server_runtimeenvironments

help_serversview_new_server

help_window_openperspective_appplatform

help_appplatform

help_appplatform_createprojectbundle

help_properties_projectfacets

help_properties_targetedruntimes

help_file_new_javaproject

help_file_new_webproject

help_buildpath_addlibraries_applicationplatformapibundles

adding_libraries_to_the_api_lib_container

help_buildpath_addlibraries_applicationplatformsharedbundles

help_run_runas_junittest

help_appplatform_createbndtemplate

help_navigatorview

help_bundlepublisherview

help_bundlemanagerview

help_window_preferences_softwareag_appplatform_bundlepublisher

help_window_preferences_softwareag_appplatform_bundlemanager

help_window_preferences_general_capabilities_softwareagappplatform

help_properties_appplatform

help_servicebrowserrview