SAP Library - Connectivity

Connectivity

Components of SAP Communication Technology

Basic Technical Concepts

Example Applications: Synchronous Communication

Application Examples: Asynchronous Communication

Example Applications: Communication with Non-ABAP Technologies

Classic SAP Technologies (ABAP)

RFC

RFC Basics

RFC Interface

RFC Communication Scenarios

Maintaining Trust Relationships between SAP Systems

RFC Administration

Limit Values for Resource Allocation for Asynchronous RFC

Configuring Resources for bgRFC

Checking RFC Authorizations

Maintaining Remote Destinations

Displaying, Maintaining, and Testing Destinations

Connection Types

Entering Destination Parameters

Technical Settings

Logon and Security

Settings for Code Pages

Preconfigured Code Pages

Special Options

Maintaining Group Destinations

Maintaining Trust Relationships between SAP Systems

Analyzing RFC Statistical Data

Monitoring tRFC

Writing RFC Programs in ABAP

Calling RFC Function Modules in ABAP

Introduction

RFC Calls

Parameter Handling in Remote Calls

Calling Remote Functions Locally

Calling Remote Functions Back

RFC Call Restrictions

Characteristics Using Unicode

RFC Exceptions

Class-Based RFC Exceptions

Semantic Considerations for Classic Exceptions

Class-Based Exceptions in Asynchronous RFC

Classic RFC Exceptions

Usnig Pre-Defined Exceptions for RFC

Exceptions That Cannot Be Handled

RFC Variants

Synchronous RFC (sRFC)

Asynchronous RFC (aRFC)

Call Properties of Asynchronous RFCs

Receiving Results from an Asynchronous RFC

Keeping the Remote Context

Parallel Processing with Asynchronous RFC

CALL FUNCTION - STARTING NEW TASK

RECEIVE

WAIT UNTIL

aRFC Programming Example

Transactional RFC (tRFC)

CALL FUNCTION - IN BACKGROUND TASK

Queued RFC (qRFC)

Writing Remote Function Modules in ABAP

Steps for Implementing Remote Function Modules

Programming Tips

Debugging Remote Function Modules

Background Communication

Queued Remote Function Call (qRFC)

qRFC Communication Model

qRFC Outbound Queue

qRFC Inbound Queue

qRFC with Outbound and Inbound Queue Process Flow

qRFC Administration

Authorizations for Administering qRFC

Outbound Queue Administration

The QOUT Scheduler

Configuring System Resources for QOUT Scheduler

Registering/Deregistering a Destination

Optimizing Performance

Monitoring the Outbound Queue

Restarting Blocked Queues

Testing the qRFC Connection

Inbound Queue Administration

The QIN Scheduler

Configuring System Resources for QIN Scheduler

Inbound Processing Details

Executing qRFC Calls Locally

Registering the Inbound Queue

Monitoring the Inbound Queue

Checking Queue Status

Specifying Log-On Data for RFC Destinations

Display Management Data

qRFC Programming

qRFC Design

qRFC with Outbound Queue

Transferring Queue Names

qRFC with Inbound Queue

Transferring Queue Names to the Inbound Queue

qRFC API

qRFC API for the Outbound Queue

qRFC API for the Inbound Queue

qRFC API: Example Program

bgRFC (Background Remote Function Call)

bgRFC Architecture

bgRFC Configuration

Creating a Supervisor Destination

Creating Inbound Destinations

bgRFC Scheduler: System-Specific Settings

bgRFC Scheduler: Application Server-Specific Settings

bgRFC Scheduler: Destination-Specific Settings

bgRFC Administration

bgRFC Authorizations

Authorization Object S_BGRFC

Debug Authorizations for bgRFC

Troubleshooting and Monitoring

bgRFC Monitor

Debugging bgRFC Units

Debugging Using the bgRFC Monitor

Debugging with External Breakpoints

API of bgRFC Type t and bgRFC Type q

Calling a Function Module

Transactional Consistency Check

Creating a Destination Object and Unit Objects

Manipulating a Background Unit

Using Queues to Lock and Unlock Units

RFC Client-Side Runtime Control

RFC Server-Side Runtime Control

New Data Types

Exception Handling

Examples for Inbound and Outbound Processing

Locking a bgRFC Type t Unit

Locking a Queue

Filling Multiple Units in Parallel

Local Data Queue (LDQ)

LDQ: Administration and Monitoring

LDQ Monitor

LDQ Programming

LDQ: Overview and Architecture

Class Description

Classes in the LDQ API - "Write"

Classes in the LDQ API - "Read"

Examples for LDQ API "Write" and "Read"

LDQ API "Write"

LDQ API "Read"

"Read" with Initial Confirm and Forecast

Repeated Read-and-Confirm Cycles

IDoc Interface/ALE

Introduction

IDoc Interface/Electronic Data Interchange

Application Link Enabling (ALE)

Monitoring the Inbound Queue

Monitoring the Outbound Queue

Error and Status Processing

Active Monitoring

Scheduling a Monitoring Job (Example)

Archiving IDocs

Displaying or Changing the Archivable Status

Archiving Functions for IDocs

Archiving and Deleting IDocs

Listing IDoc Numbers in Archive

IDoc Search

Archiving: Technical Implementation

Authorizations for IDoc Archiving

Archiving: Descriptions of Standard Reports

Database Tables

Deleting Links with IDocs

Additional Settings

IDoc Administration: Global Parameters

Deactivate Links

Forward Inbound

Generating File Names

Checking Partners by Partner Type

Displaying an IDoc Using an XSL Stylesheet

IDoc Views

Queue Name Rules

Encrypting the Display of Sensitive Data

Debugging in IDoc Inbox/Outbox

Defining Debug Points

Administration of ALE Functions

Message Exchange Monitoring

Central Monitoring Using the ALE CCMS Monitor

Status Monitor for ALE Messages

Monitoring the Status of Inbound IDocs Using ALE Audit

Segments of Audit IDoc ALEAUD01

Evaluating the Audit Database

Tracing IDocs System-Wide

Workflow Connection for ALE Functions

Error and Status Processing

ALE Customizing Data

Synchronizing Application Customizing Data Between Systems

ALE Basis Customizing Data

Converting ALE Basis Customizing Data

Specify Conversion Matrix

Conversion

ALE Basis Customizing Data Check Center

Technical Data of User System

Conversion of ALE Basic Customizing Data

Check Distribution Model

Check/Generate Partner Profiles

Check Communication Partners

Enhance Checks

Optimizing ALE Performance

Control of IDoc Events

Scheduling IDoc Creation

Scheduling IDoc Transfer to the Communication Layer

Scheduling IDoc Posting

Processing IDocs in Parallel

Creating IDocs in Parallel

Sending IDocs in Parallel

Posting IDocs in Parallel

Processing IDoc Packets

Creating IDoc Packets

Sending IDoc Packets

Posting IDoc Packets

Administration of IDoc Communication

Suppressing Background Processing

Setting Dispatch Status to Dispatch OK

Check the tRFC Status

Archiving and Reorganization

Serialization of Messages

Serialization by Object Type

Serialization by Message Type

Serialization at IDoc Level

Periodic Tasks

Change Pointer (Master Data Distribution)

Analyze Change Pointers

Reorganizion of Change Pointers

Conversion of Logical Systems

Conversion of Logical Systems (as of NetWeaver 6.20)

Converting Data Between Sender and Receiver

ALE Recovery for Data Consistency

Development

Structure, Documentation, and Definition of IDoc Types

IDoc Structure

IDoc Structure: Technical Implementation

Documentation Tools

Translating Documentation

Defining New IDoc Types

Important Terms

Basic Type, Enhancement, IDoc Type

Segment Type and Segment Definition

Customer Enhancements, SAP and Customer Developments

Version Creation and Release Procedure

Namespaces

Design Guidelines and Formatting Rules for Creating New Segments

Design Guidelines for Creating New IDoc Types

API for IDoc Types and Segment Definitions

Enhancing an IDoc Type

Combining Segments

Enhancing a Basic Type

Assign Message Type to Basic Type and Extension

Enhancing Outbound Function Modules

Changing Partner Profiles (Outbound)

Testing Outbound Processing

Enhancing Inbound Function Modules

Enhancing Function Module Assignments (Direct Inbound)

Checking Partner Profiles (Inbound)

Testing Inbound Processing

Releasing New Objects

Defining and Using a Basic Type

General Definitions

Defining Segments

Defining a Basic Type

Assigning Basic Types to Message Types

Defining Object Types

Configuring Outbound Processing (with Message Control)

Creating a Function Module (Outbound Processing under MC)

Assigning a Process Code (Outbound Processing)

Defining a Partner (Outbound Processing)

Testing Outbound Processing

Configuring Direct Inbound Processing with ALE

Creating a Function Module (Direct Inbound Processing)

Maintaining the Attributes of a Function Module

Assigning a Function Module (Direct Inbound Processing)

Assigning a Process Code (Direct Inbound Processing)

Defining a Partner (Direct Inbound Processing)

Creating a Task (Exception)

Testing Inbound Processing

Testing Exception Handling

Configuring Inbound Processing Using a Workflow

Defining Inbound Processing as an Object Method

Creating a Task (Inbound Processing Using Workflow)

Creating a Process Code (Inbound Processing Using Workflow)

Creating a Task (Exception)

Defining a Partner (Inbound Processing Using Workflow)

Testing Inbound Processing

Testing Exception Handling

Releasing New Objects

Troubleshooting in Workflow Processing

ALE Programming Guide

Test Environment

Testing IDoc Processing

Test Tool

Outbound Test Tool: Procedure

Inbound Test Tool: Procedure

Test: Outbound Processing from MC

Test: Outbound Processing from IDoc

Test: Inbound Status File

Generating a Status File

Test: Inbound Processing: Modified Outbound File

Test: Inbound Processing: Original Inbound File

Error and Status Processing

BAPI

General Introduction to BAPIs (CA-BFA)

Objectives for Implementing BAPIs

Universal Usability of BAPIs

Business Object Types

The Business Object Repository

BAPI Information Landscape

BAPI User Guide (CA-BFA)

BAPI Programming Guide (CA-BFA)

Enhancement and Modifications of BAPIs (CA-BFA)

Communication Between ABAP and Non-ABAP Technologies

SAP Java Connector

SAP JCo Functions

SAP JCo Application Scenarios

SAP JCo Scenario: Java/ABAP Communication in the Application Ser

SAP JCo and the VM Container

Managing Work Processes in the VM Container

In-Process and Out-of-Process Communication

Logging and Tracing for Using SAP JCo with VMC

Profile Parameters for Logging and Tracing

SAP JCo Scenario: SAP BC

SAP JCo Scenario: Online Invoice

SAP JCo Configuration

SAP JCo Administration

Executing Functions

SAP Java Resource Adapter

SAP JRA for SAP Java Applications

SAP JRA Architecture

SAP JRA Configuration

SAP JRA Configuration: Procedure

Parameters for SAP JRA Configuration

Managing Calls from Multiple SAP Systems

SAP JRA Development Guidelines

SAP JRA Configuration on the Application Server Java

Client Programming Model

Transactions for the Client Programming Model

LocalTransaction

UserTransaction

Container Managed Transaction

Security for the Client Programming Model

BasicPassword

Kerbv5 (SSO)

DefaultAuthentication

Application Managed Authentication

Secure Network Connection (SNC)

Server Programming Model

Callback

Stateful Communication

Security for the Server Programming Model

SSO

SNC

Handling Records

Facades and Compilation

Exception Handling

Internet Communication Framework

Architecture

Server Architecture

Client Architecture

Classes and Interfaces for the Server Role

IF_HTTP_RESPONSE and IF_HTTP_REQUEST

Methods for IF_HTTP_RESPONSE and IF_HTTP_REQUEST

IF_HTTP_ENTITY

Attributes for IF_HTTP_ENTITY

IF_HTTP_EXTENSION

Attributes

Constants for Describing the Control Flow

Constants for Describing Lifetime Control

Methods

IF_HTTP_UTILITY

Methods for Interface IF_HTTP_UTILITY

Classes and Interfaces for the Client Role

Interface IF_HTTP_CLIENT

Server Function Administration

Authorizations

Authorization Object S_ICF

Authorization Object S_ICF_ADM

Authorization Object S_ICFREC

Restricting Authorizations for Transaction SICF

Determining Authorizations in the Target System

Client Function Administration

Establishing a Connection Using a Destination (SM59)

Parallel Requests

Configuring a Proxy

Error Handling and Monitoring

Fehleranalyse: Vorgehen

External Debugging

External Debugging under Load Distribution

Displaying and Processing Entries

Authorization Object S_ICFREC

Maintaining the ICF Profile Parameters

Managing Error Information

Performancemessungen

Troubleshooting Using Central Monitoring Functions

Statistical Data for RFC and ICF

Development

Server-Side Development

HTTP Request Handler

Developing a HTTP Request Handler

Creating an HTTP Request Handler

Accessing Header Fields

List of the Pseudo Header Fields

Accessing Form Fields

Accessing Cookies

Accessing HTTP Body Data

Accessing HTTP Multipart Data

Stateless/Stateful Communication

Terminating a Session

Code Page in ICF

Compression Techniques

Creating and Configuring ICF Services

Create Service

Maintaining Logon Procedures

Logon Checks: Overview

Standard Logon Order

Alternative Logon Order

Logon Using Service Data

Logon with SSL Certificate

Logon Using Tickets

Logon Using Basic Authentication.

Logon via SAML

Specifying the Client

Determining the Logon Language

Defining Service Data

HTTP Load Distribution

Defining Security Requirements

Setting Up Error Pages

Format and Parameters of the Error Document

Inserting an HTTP Request Handler

Activating and Deactivating ICF Services

Creating Virtual Hosts

Virtual Hosts: Application Example

Internal Aliases

External Aliases

Testing the HTTP Request Handler

Transporting ICF Services

Client-Side Development

Example program: Executing an HTTP Request

Parallel Processing Requests

Redirecting Requests

Web Service Technologies in the Application Server

Beispiel: SOAP Message

Example: WSDL File

SAP Gateway

Architecture of the SAP Gateway

The SAP Gateway and the SNC Interface

Load Balancing for Registered Programs

Memory Management of the SAP Gateway

Controlling Caching of IP Addresses

Administration of the SAP Gateway

Starting and Stopping the SAP Gateway

Configuring the SAP Gateway

Parameterization of the SAP Gateway

Configuration Parameters

Load Balancing Parameters

Network Parameters

Timeout Parameters

Resource Management Parameters

Security Settings in the SAP Gateway

Setting Up Access Control Lists (ACL)

Configuring Support of SNC Components

Setting Up Gateway Logging

Evaluating the Log File

Making Security Settings for External Programs

Setting Up Logging-Based Configuration

Gateway Security Files secinfo and reginfo

Security Parameters

Checking Security Configuration

Monitoring and Error Handling in the SAP Gateway

Using the SAP Gateway Monitor Outside the SAP System

Display Active CPI-C Connections

Displaying Logged On Clients

Connection Attributes

Gateway Statistics

Display Security Information

Expert Functions

Troubleshooting

Errors When Starting RFC Programs

Error Codes

XML- Library

Package DOM

Interface if_ixml_att_list_decl

Interface if_ixml_attribute

Interface if_ixml_attribute_decl

Interface if_ixml_cdata_section

Interface if_ixml_character_data

Interface if_ixml_comment

Interface if_ixml_cond_dtd_section

Interface if_ixml_content_particle

Interface if_ixml_document

Interface if_ixml_document_fragment

Interface if_ixml_document_type

Interface if_ixml_element

Interface if_ixml_element_decl

Interface if_ixml_entity_decl

Interface if_ixml_entity_ref

Interface if_ixml_named_node_map

Interface if_ixml_namespace_context

Interface if_ixml_namespace_decl

Interface if_ixml_node

Interface if_ixml_node_collection

Interface if_ixml_node_filter

Interface if_ixml_node_filter_combining

Interface if_ixml_node_iterator

Interface if_ixml_node_list

Interface if_ixml_notation_decl

Interface if_ixml_pi

Interface if_ixml_pi_parsed

Interface if_ixml_pi_unparsed

Interface if_ixml_text

Package Encoding

Interface if_ixml_encoding

Package Event

Interface if_ixml_event

Package iXML

Interface if_ixml

Package Parser

Interface if_ixml_parse_error

Interface if_ixml_parser

Package Renderer

Interface if_ixml_renderer

Package Stream

Interface if_ixml_istream

Interface if_ixml_ostream

Interface if_ixml_stream

Interface if_ixml_stream_factory

Package Unknown

Interface if_ixml_unknown

iXML ABAP Objects Jumpstart

Things you should know in advance

A sample XML document

What services does iXML provide

What programming languages does iXML support

What operating platforms does iXML support

Enabling the iXML library

Basic steps in your program

Parsing an XML document DOM-based

Parsing an XML document event-based

Casting up and down the inheritance hierarchy

Creating a DOM tree from scratch

Traversing the DOM tree

Traversing the DOM tree with iterators

Traversing the DOM tree with filters

Rendering a DOM tree into an XML document

SAP XSLT Processor Reference

Statements

Creating the Result Tree

Flow Control

Defining and Calling Template Rules

Stylesheets and Structuring

Top-Level Help Statements

Output

Additional SAP Statements

sap:call-external

sap:external-function

Additional SAP Functions

Preprocessor Sequences

General Constraints