A new feature, Integrated Configurations, is introduced in PI 7.1. This feature allows us to configure an end-to-end scenario that will process messages locally in the Advanced Adapter Engine (AAE), bypassing the Integration Engine (ABAP stack of the Integration Server). The Advanced Adapter Engine is the new name in PI 7.1 for the Adapter Engine.

The primary objective of using local processing in the AAE is to increase the performance of message processing by eliminating the need for the ABAP stack during the process. By bypassing the ABAP stack, the message processing will still keep the existing mapping, monitoring and support functionalities.

Since the ABAP stack no longer participates in the processing of messages, therefore, any functionality provided by ABAP will not be available when the Integrated Configurations option is selected for message processing.

A detail article of the step-by-step guide, as well as the benefits and limitations of using "Integrated Configurations" in PI 7.1's AAE is available from:

How To: Configure Integrated Configurations in the Advanced Adapter Engine

Architecture

Runtime Picture: From...

image image

To...

image image

In PI 7.0 and XI 3.0, one of the most often requested features (or complaints) is the capability (or lack of) to share user-defined functions (UDFs) across multiple message mappings. As a result, we often had to duplicate the code of frequently used UDFs to multiple message mappings.

This feature is now available with PI 7.1. The only restriction is that the library containing the UDFs has to be in the same Software Component Version (SWCV) as the message mapping. Therefore, if we wish to share the library in more than 1 SWCV, then we will need to create dependencies in the System Landscape Directory (SLD).

In this blog, I will discuss how to created and use UDFs that can be shared with multiple message mappings.

For demostration purposes, I will create a UDF to calculate the factorial of a number in a function library. Then, use this function library's UDF in a message mapping.

Below is the simple procedure:

  1. Create a Library and an User-Define Function to be shared.

    A Function Library can be create in any namespace under a SWCV. The Function Library, then, can be referenced from any namespace under the SWCV.

    I am going to create a function library in the namespace, http://test.com/shared, called "myUdfLibrary".

    Right-click on the namespace and select "New":
    image

    Select "Function Library", enter the name "myUdfLibrary", and click on "Create":
    image

    The following screen will appear. Then, follow the procedure below:

    1. Click on the "+" in "Functions and Java Area".
    2. Enter the function name, "ComputeFactorial".
    3. Enter "ComputeFactorial" as the Title.
    4. Enter the java code.
    5. Save and Activate.
    image
  2. Use the User-Defined Function in the Function Library.

    Here, we are just going to do a simple one-to-one mapping, and use the UDF to compute the factorial. But, first, we will have to reference the function library.

    Click on the new icon "Show Used Function Libraries", as below:
    image

    With the following screen.

    1. Click on the "+" in "Used Function Libraries".
    2. Click on the "down arrow" to select the function library from the value list.
    image

    Select the function library and click "Apply":
    image

    Now, we can select the function library, "myUdfLibrary", from the Message Mapping:
    image

    Now, we can use the UDF, "ComputeFactorial", just as though we had developed it in the message mapping locally.
    image

    When testing it, we get the following:
    image

In PI 7.0 and XI 3.0, we have been able to import the metadata from RFCs and IDOCs from SAP. Many times, we wish we can also import metadata from SQL tables we wish to access also. This will eliminate a lot of typing and typo-mistakes.

This feature is now available with PI 7.1. The only requirement is that we have to have a JDBC receiver communication channel.

In this blog, I will discuss the steps to import metadata from SQL tables.

For demostration purposes, I have a table, "Table1", in MS SQLServer. I will import the metadata as an external definiton into PI 7.1's Enterprise Service Repository (ESR).

Below is the simple procedure:

  1. Create a JDBC Receiver Communication Channel.

    In the Integration Directory, created a JDBC receiver communication channel. The table name is "Table1" in the database "xirig" of MS SQL Server 2005.

    Using the MS SQL Server Management Studio, we see the table layout as follow:
    image

    The communication channel configuration is as follow.
    image

  2. Import the Metadata of "Table1".

    In the ESR, create an External Definition in a namespace.

    Right-click on a namespace and select "New", as below:
    image

    Select "External Definitions" and enter "Table1" (or any name) for the name. image

    With the create screen, select "dbtab" in the dropdown for "Category" and click on the wizard to import the external definition:
    image

    In the wizard, select the Communication Component and the Communication Channel from step 1, and click "Continue":
    image

    Enter "Table1", or use the "Display" button to see all the available tables and select a table. Click "Finish":
    image

    We see the following when this is done.
    image

    When we tried to use it in a mapping, we will see the following:
    image

SAP NetWeaver Administrator 7.1 is a Web-based tool for administration and monitoring, offering a single entry point to configure, administer, and monitor your SAP NetWeaver system, its components, and applications.

This lecture introduces many of the features and functionalities available within SAP NetWeaver Administrator. Some of the main features are the following:

  • A single, central tool for administration, troubleshooting, and problem analysis of your SAP NetWeaver system. You can perform administration tasks, such as starting and stopping instances, checking and modifying configuration settings, and analyzing logs and traces.
  • An easy-to-use, task-oriented interface
  • A Web-based tool, which does not need to have a local installation to manage remote systems
  • The interface allows seamless navigation to other SAP NetWeaver administration tools (e.g. User Management Engine)
  • The SAP NetWeaver Administrator represents the crossover from various expert tools to an integrated, simple, and clear solution. It also completes the integration of the data sources for monitoring.

This lecture will also cover the following areas for PI 7.1:

  • An overview of monitoring of Exchange Infrastructure using NWA
  • Understanding the architecture of WS-RM
  • An overview of monitoring WS messages in NWA
  • An overview of using webservice with point-to-point connections using Exchange Infrastructure
  • Using NWA to create and test WS provider service
Hello everyone. We are again presenting an exciting conference with even more interesting and useful sessions than before, especially in the Process Integration (or Exchange Infrastructure) area.


Introduction

The EPI351 hands-on session is going to lead you step-by-step on how to develop a Java EE adapter user-module. You will be able to use the steps given in the workshop on your own system when you go back. In addition, the code we used in class can easily be modified to accommodate your own need.

As we get more sophisticated in using PI, we start to contemplate all kinds of possibilities how we can process even more interesting interfaces. Some of these interfaces, at first glance, may appear to be impossible. But, with the help of user-modules, we will now have a gleam in our eyes which will say "humm...I think I can...".

Adapter user-module introduces capabilities to process messages which seemingly would not be possible. An example is using PGP to read an encrypt message, or to produce an encrypted message for your business partner.

We will also be using the Partner Connectivity Kit (PCK) during this workshop. PCK is a very powerful tool which can be use to test our user-modules without an XI system. Since PCK only requires a J2EE engine, therefore, small enough to be installed on our laptop, we can develop our user-module while travelling, e.g. on an airplane. Yes, your company will love this. You will now be working during all your waking hours, without having to be connected.

This workshop is a repeat of a similar workshop in last year's TechEd. It has been updated to use NWDS 7.1 and Java EE 1.5.

Workshop Detail

At the end of this workshop, you will:

  1. Understand the architecture of SAP PI Adapter Framework
  2. Use the NetWeaver Developer Studio to develop and deploy the adapter module
  3. Use PCK to test the adapter module
  4. Understand the requirement and steps during the development process
  5. Configure the adapter module in the adapter communication channel
  6. Monitor the adapter module processing in the RWB
To save time, we have pre-configured the PCK and the test interface to test the user-module. But, we have included these configurations in the handouts so that you can duplicate them on your own systems.


I hope see you all there.

Many web applications we are asked to integrate with may not be XML-based or webservice-enabled. They are existing web applications using the HTTP/HTML protocol, requiring us to post data to them. The HTTP adapter can be used for this situation. However, using it can sometimes lead to uncertainty as to what exactly are being sent or posted to these 3rd-party web application. The url element contains the value of the URL to be used when posting to the 3rd-party application. It will override whatever has been hardcoded in the HTTP receiver communication channel.

 

 

 

The parmValue contains all the parameter values in the URL. In another word, they are the values to be posted. The key values for the URL parameters are configured in the HTTP receiver communication channel (see below). </p><p>The HTTP receiver communication channel configuration for the URL parameter key values: (the order of the parameter values in the source XML correspond to the order of the Parameter configuration below)<br/>!https://weblogs.sdn.sap.com/weblogs/images/4172/HPT1.jpg|height=400|alt=image|width=507|src=https://weblogs.sdn.sap.com/weblogs/images/4172/HPT1.jpg|border=0! <br/>Also, please note below that the "Target Host", "Service Number" and "Path" are irrelevant. They will be replaced by the URL in the source XML.<br/>!https://weblogs.sdn.sap.com/weblogs/images/4172/HPT2.jpg|height=400|alt=image|width=513|src=https://weblogs.sdn.sap.com/weblogs/images/4172/HPT2.jpg|border=0! </p><p>The Message Mapping: <br/>!https://weblogs.sdn.sap.com/weblogs/images/4172/HPT3.jpg|height=382|alt=image|width=600|src=https://weblogs.sdn.sap.com/weblogs/images/4172/HPT3.jpg|border=0! </p><p>The User-Defined Function, "AssignURLValue": <br/><textarea cols="65" rows="20">public void AssignURLValues(String[] url,String[] urlParm,ResultList result,Container container){      DynamicConfiguration conf = (DynamicConfiguration) container.getTransformationParameters().get(StreamTransformationConstants.DYNAMIC_CONFIGURATION);      DynamicConfigurationKey parmValue;      // TargetURL      parmValue = DynamicConfigurationKey.create( "http://sap.com/xi/XI/System/HTTP", "TargetURL");      conf.put(parmValue, url[0]);      // URL Parameters      switch(urlParm.length) {      case 6:        parmValue = DynamicConfigurationKey.create( "http://sap.com/xi/XI/System/HTTP", "UrlParamSix");        conf.put(parmValue, urlParm[5]);      case 5:        parmValue = DynamicConfigurationKey.create( "http://sap.com/xi/XI/System/HTTP", "UrlParamFive");        conf.put(parmValue, urlParm[4]);      case 4:        parmValue = DynamicConfigurationKey.create( "http://sap.com/xi/XI/System/HTTP", "UrlParamFour");        conf.put(parmValue, urlParm[3]);      case 3:        parmValue = DynamicConfigurationKey.create( "http://sap.com/xi/XI/System/HTTP", "UrlParamThree");        conf.put(parmValue, urlParm[2]);      case 2:        parmValue = DynamicConfigurationKey.create( "http://sap.com/xi/XI/System/HTTP", "UrlParamTwo");        conf.put(parmValue, urlParm[1]);      case 1:        parmValue = DynamicConfigurationKey.create( "http://sap.com/xi/XI/System/HTTP", "UrlParamOne");        conf.put(parmValue, urlParm[0]);      } } </textarea> <br/>As you can see, we do not map anything to the target XML. The only thing we are interested is to populate the URL and URL parameters. Therefore, the user-defined function does no mapping, instead its only purpose is to assign values dynamically from the source XML to the communication channel configuration. </p>h4. 2. Verifying What Has Been Posted Now we have, supposely, configured the URL and the URL parameters to be posted. But, how can we be sure. Will all the parameters be sent? One way to find out is just to send it and hope that everything works out. But, if it doesn't, how do we determine where is the problem? Was it because we did not post the parmaeters correctly, or the receiving application doesn't work as expected? <p>In order to determine what has been sent, I developed a simple .asp application which returns all the URL information, including the following: query parameter, header information, payload, etc. The reason .asp was used is because most of us has a Windows system, where IIS can easily be installed or already installed. The .asp application can simply be copied to the "wwwroot" directory. The filename must be "displayPostData1.asp". You can change the filename, but, at the same time, you must also change the URL in this example. </p><p>Below is the displayPostData1.asp program: <br/><textarea cols="65" rows="30"><% 'dim fs,f 'set fs=Server.CreateObject("Scripting.FileSystemObject") 'set f=fs.GetFile("C:\data\HTTP\foo.txt") 'f.Attributes=32 'Response.Write("The attributes of the file are: ") 'Response.Write(f.Attributes) 'set f=nothing 'set fs=nothing 'Adjust this depending on the size of the files you'll 'be expecting; longer timeout for larger files! Server.ScriptTimeout = 5400 'Yank the file (and anything else) that was posted PostData = "" PostData = "Query String " & Chr(13) & Chr(10) PostData = PostData & "=============" & Chr(13) & Chr(10) PostData = PostData & Request.QueryString & Chr(13) & Chr(10) PostData = PostData & Chr(13) & Chr(10) PostData = PostData & "Header Fields" & Chr(13) & Chr(10) PostData = PostData & "=============" & Chr(13) & Chr(10) for each header in Request.ServerVariables      PostData = PostData & header & "=" & Request.ServerVariables(header) & Chr(13) & Chr(10) next PostData = PostData & Chr(13) & Chr(10) PostData = PostData & "Payload Data " & Chr(13) & Chr(10) PostData = PostData & "=============" & Chr(13) & Chr(10) Dim biData biData = Request.BinaryRead(Request.TotalBytes) 'Careful! It's binary! So, let's change it into 'something a bit more manageable. For nIndex = 1 to LenB(biData)      PostData = PostData & Chr(AscB(MidB(biData,nIndex,1))) Next 'IIS may hang if you don't explicitly return SOMETHING. 'So, redirect to another page or provide some kind of 'feedback below... %> <%response.write(PostData)%> </textarea> <br/>The above .asp program displays everything about the URL, not just the URL parameters, so you can use it to examine every piece of information sent by your HTTP communication channel. </p><p>To use it, the interface needs to be synchronous, and you can use the test tool in the Runtime Workbench. </p><p>For our example, after executing it, we can go to the SXI_MONITOR and look at the response document, which contains the content of the URL information sent by the HTTP receiver communication channel. </p><p>The content is of the URL is: <br/>!https://weblogs.sdn.sap.com/weblogs/images/4172/HPT4.jpg|height=400|alt=image|width=595|src=https://weblogs.sdn.sap.com/weblogs/images/4172/HPT4.jpg|border=0!</body>

William Li

Using Folders in PI 7.1

Posted by William Li Aug 7, 2007
With the development tools in NW PI 7.1, folders are introduced. Folders can be used as an additional option to organize projects and interfaces.

In this blog, I will discuss how folders are used, and their pros and cons.

Folders are available in both the Enterprise Service Repository (ESR) and the Integration Directory (ID). Yes, ESR is the replacement for what we have been used to as the Integration Repository in PI 7.0 and XI 3.0. ESR contains many enhancements and additions, one of which is the use of folders. Other features of the ESR will be discussed in other blogs.

I will discuss the use of folders in 2 different sections: ESR and ID

  1. Enterprise Service Repository.

    In the ESR, the use of folders can easily be adopted. It is very much similar to what we have been used to in working with the Windows File Explorer. It is an additional way to allow us to organize our projects and interfaces. However, there is a minor difference of how the objects will be displayed, with and wihout using folders.

    Folders can be created under a namespace. As you will notice, mulitple folders can be created under the same namespace. And, folders can be created within folders.

    image

    As you can see in the above, A contains ESR objects created within a folder. B contains ESR objects created without a folder.

    The obvious difference is that without using a folder, ESR objects are organized under specific object groups, e.g. Data Types, Message Types, Service Interfaces (evolved from Message Interfaces). This is identical to what we are used to in PI 7.0.

    When a folder is used, the objects created within the folder are no longer organized within object groups. We must use either the icons or our own naming convention to identify the object type, or we can create folders to group the different object types.

    One convenience of using folders is that when we wish to delete the objects inside a folder, we can just delete the folder.

    Recommendation:

    • It is not necessary for us to use folders, especially for those of us who are starting out with PI development and are still relying on the grouping of the objects to facilitate our development smoothly. In most cases, we have been doing fine by organizing our projects by using SWCVs and namespaces.
    • For those cases where the interfaces for scenario become complex, and we wish to more logically separate the objects to ease our development and support tasks (e.g. to separate source and target interfaces), then folders can be very helpful. It is also very useful when we want to create many different test interfaces during development and do not wish to create additional SWCVs and namespaces. Many times by lumping all the test interfaces under the same namespace can be very confusing.
    • Need to control authorization to specific objects. By using Folders, we can easily control access to view and change the design objects based on groups assigned to userids.
  2. Integration Directory.

    The affect of using folders in the ID is much more dramatic. I think the advantages and disadvantages will be debated for many moons to come.

    Before we get into folders, let us talk about Scenarios first. I think they are somewhat related, as they both help us to organize our applications.

    In PI 7.0 and XI 3.0, we organize our end-to-end integration processes using "Configuration Scenarios". Within each Scenario, we can include configurations for Communication Channels, Sender and Receiver Agreements, Receiver Determinations, etc. The scenarios are also used for transports between the landscapes. The scenario allows us to see only those relevant objects we need for our integration application.

    First, let us take a look at a Scenario in PI 7.0.

    image

    There is a Scenarios tab. And, under each Scenario, we can find all the configuration objects for that scenario. The objects inside each Scenario are logical pointers to the actual objects in the Objects tab, therefore, if an object is used in multitple Scenarios, then that object can show up in everyone of them.

    Now, let us take a look at Scenario in PI 7.1.

    image

    If you notice, the "Scenarios" tab is gone. Scenario is now under Objects, as a header for a grouping of Scenarios. Also, you cannot expand a scenario on the left panel to see all the relevant objects, as in PI 7.0. You can only see those objects on the right panel, after double-clicking on the scenario. Of course, you can then detach the panel or form to simulate the prior functionality.

    From usability perspective, this is probably a "take-away". Of course, this is probably where Folder can come in and replace that feature. Then, if so, why do we still have Scenarios? So, let's continue.

    Below is a screenshot of folders in PI 7.1.

    image

    Similarly to ESR, folders can have more folders, this is very much like directories and subdirectories in File Explorer. The objects in a folder can be displayed just as in PI 7.0's Scenarios. And, when you double-click on an object, the object will be opened on the right panel.

    However, there is one big difference between Folders in PI 7.1 and Scenarios in PI 7.0. The objects in Folders are not logical pointers to "actual" objects, as in Scenarios. This means that when an object is contained in one folder, this object cannot be present (or shown) in another folder. And, if you move that object to another folder, it will physically be moved. The original folder will no longer contain that object. This is just like files in directories. For example, if a folder contains a Business System, then this Business System will not, and cannot, be shown in any other place. This makes very difficult to determine whether a Business System has already been assigned to the ID, or if a Communication Channel has already been configured, because they might exist (or hidden) in a folder created by someone else (or moved by someone else to his own folder). You will not be able to see all the Communication Channels for a Business System in one place, because they may be spread across many folders. You will have to use the Search tool to find them, or turn off the Folder view (see below).

    As a result, using Folders can be risky, because you may end up either creating duplicate objects, or have to spend time looking for an object. Consequently, we must plan very carefully and agree upon standards or rules when using Folders.

    The main benefit of Folders is that you can create access authorizations to folders, e.g. this can prevent access by just anyone to see or change the configurations of an integration process or specific objects.

    Recommendation:

    • Use Folders when you need to control access to objects in the ID.
    • Plan and establish rules and standards when using folders, such as create a shared folder to contain all the shared objects, e.g. Business Systems and Communication Channels.
    • Continue to use Scenarios, even though the usability may have been decreased.

    Incidently, you can go back to the "old" view, without seeing any folders, by filtering it out.

    image

When we consume webservices from another system, we use the SOAP receiver adapter. Even though the configuration seems simple and is well documented in SAP Help, but when something does not work, we are still sometimes at a loss as to where to start.

This blog will attempt to go through a debugging process which has been pretty successful so far for me.

When consuming a webservice from an external systems, problems are normally caused by the following:

  1. Invalid or missing configuration parameters in the communication channel configuration.
  2. Firewall/proxy and authorization problem.
  3. Message/interface structure not compatible with the published webservice interface.
  4. The webservice on the external system has errors.

When we consume a webservice of an external application, we must have the WSDL file. This file is either given to us, or can be accessed from an URL or a registry/directory (e.g. UDDI). Download or copy the content of the WSDL into a local file, use ".wsdl" as the file type. This WSDL contains the necessary information for us to design and configure our interface scenario.

Before we start on any XI design or configuration, we SHOULD verify that the webservice does work. This can eliminate a lot of headache when trying to determine the source of the problem in the future. If the webservice does not work as advertised, then we should contact the provider. We should not proceed until the webservice problem is resolved, because we could receive a different WSDL file, resulting in interface and mapping changes.

To test the service, a SOAP client tool will be required. There are many on the internet. The one I use is soapUI from http://soapui.org, which is a free and open source desktop application for inspecting, invoking, developing, simulating/mocking and functional/load/compliance testing of web services over HTTP.

Download soapUI and install it on your computer. Create a project and load the WSDL file. Execute or test the webservice. During this process, the proper proxy and authrization parameters will also be needed. These information will be useful because they will also be needed in the communication channel configuration. So, in effect, we are using this tool to determine and verify all the configurations required in our XI configurations. Since XI is not involved during this process, we can eliminate XI as a source of any errors.

Below is a sample of the screen from soapUI: (by double-clicking on "Request 1", the test screen on the right will be shown; also note the left-lower screen which allow us to enter the userid and password to access the webservice application)

image

If proxy configuration is required to access the external URL, it can be entered using top menu: File -> Preferences:

image

When the webservice is submitted, by clicking on the green arrow, the response will be return on the right screen.

image

In this example, there is an error, which is in HTML format and not readable unless we viewed it using a browser. So, we can copy-n-paste the content into a local .HTML file and view it using an internet browser, which we can see an "HTTP 401 Unauthorized" error, caused by invalid userid/password.

image

After correcting the userid/password, I re-submitted the test and encountered another error: (this error indicated an application error, with an HTTP 500 - Internal Server Error)

Application error will not usually be shown in XI Monitor and is very difficult to determine the cause without a SOAP client test tool. For this case, we should contact the provider with the error encountered.

image

After the webservice application has been corrected, we can now proceed with our XI design and configuration. To minimize errors:

  1. In the Integration Repository, it is very important to import the WSDL as "External Definition" in "Interface Objects", and use it in designing your interfaces and mappings. Do NOT define your own datatype when using a webservice. Always use the WSDL file. When there is a problem with payload error, verify that the WSDL file is used and that it is the latest one.
  2. When configuring the SOAP Receiver Communication Channel:
    • The "Target URL" value can be obtained from the WSDL file. Look for the attribute, "location", of the element, "address". Copy-n-paste this value, exactly as is.
    • The "SOAP Action" value can also be obtained from the WSDL file. Look for the attribute, "soapAction", of the element, "operation". Some webservices has no value (blank) for soapAction, while others have more than 1. Use the soapAction appropriate to what method needs to be executed, e.g. soapAction can indicate whether a create or a delete is to be performed, so be careful.
    • Select the configurations for "User Authentication" and "Proxy" as required.

The above consists of the most common configurations for a SOAP receiver communication channel. In most situations, if the webservice is verified before configuration, and the valid configuration parameters are also validated, we should have minimum problems using webservices during integration.

When error does occur, go through the above checklist and verify the configurations.

Also, when problem occurs during testing of the XI scenario, we can also copy-n-paste the payload, after mapping, into the soapUI tool, replacing the text between the and with the content of the payload (and do not include the 1st line,

Using JDBC Connection Pool in XI Message Mapping

In XI Message Mapping, many time we have needs to lookup values from SQL tables. There are 3 primary ways to execute SQL statements from Message Mapping:
  1. Develop a user-function to connect to a datasource and execute the SQL statement.
  2. Use a Receiver JDBC Communication Channel to connect to a datasource and execute the SQL statement.
  3. Use a J2EE JDBC connection pool to connect to a datasource and execute the SQL statement.

Method 1 is the most inefficient, and the least desirable. For each lookup, a connection to the database will have be made. The resources required to make a database connection maybe greater than executing the SQL statement itself. In addition, userid/password to access the datasource will have to be included in the java source code.

Method 2 provides the most flexibility to the developer, since the developer can create and configure the communication channel in the Integration Directory. However, the number of threads for the JDBC receiver communication channel is limited and may create a performance bottleneck if many scenarios are also using the same communication channel.

Method 3 is the most efficient way and does not require any interface design in the Integration Repository. The connections in the pool are shared by everyone, even non-XI applications. There is no overhead of repeated connections to the datasource. The maximum number of concurrent connections can be dynamically changed. Virtually any SQL statement can be executed. However, some preparation and setup are required.

In this blog, we will go through the procedure is setting up a Message Mapping using method 3. Please note, access to the J2EE Visual Administrator will be required.

This blog will also give 3 datasource configuration examples. One example using SQLServer, and two examples using Oracle.

There are 3 steps involved:

  1. Create/configure the JDBC datasource in the J2EE Visual Administrator.
  2. Develop a generic java class to access any datasource and execute any SQL statement.
  3. Develop a simple user-function in Message Mapping to use the java class from the previous step.

Here are the steps:

  1. Create/configure the JDBC datasource in the Visual Administrator.
    1. Login to the J2EE Visual Administrator and go to: Server 0 -> Services -> JDBC Connector

      image

    2. Add a JDBC driver.

      image

      In this example, I added 2 JDBC drivers: (The vendor-specific JDBC drivers can be downloaded from the vendor's website. Make sure the driver version corresponds to the database version to be accessed.)

      • Oracle requires ojdbc14.jar
      • SQLServer requires msbase.jar, mssqlserver.jar and msutil.jar
    3. Create a JDBC datasource.

      image

      Following are 3 examples of datasources:

      • Oracle JDBC Version 1.x (no XA support)

        image
        Driver Name: Oracle10 (based on configuration in the previous step)
        JDBC Version: 1.x (no XA support)
        Driver Class: oracle.jdbc.driver.OracleDriver
        Database URL: jdbc:oracle:thin:@localhost:1521:orcl
        Enter valid userid and password for the database

        image

      • Oracle JDBC Version 2.0 (with XA support)

        image
        Driver Name: Oracle10 (based on configuration in the previous step)
        JDBC Version: 2.0 (with XA support)
        Object Factory: oracle.jdbc.pool.OracleDataSourceFactory
        DataSource Type: XADataSource
        XADS Classname: oracle.jdbc.xa.client.OracleXADataSource

        image
        url: jdbc:oracle:thin:@localhost:1521:orcl
        Enter valid userid and password for the database

      • SQLServer JDBC Version 1.x (no XA support)

        image
        Driver Name: SQLServer (based on configuration in the previous step)
        JDBC Version: 1.x (no XA support)
        Driver Class: com.microsoft.jdbc.sqlserver.SQLServerDriver
        Database URL: jdbc:microsoft:sqlserver://localhost:1433;databaseName=xirig
        Enter valid userid and password for the database

        image

  2. Develop a generic java class to access any datasource and execute any SQL statement.

    An example source code is below:

    Create a ZIP or JAR file and import it as an Imported Archive for mapping.

  3. Develop a simple user-function in Message Mapping to use the java class from the previous step.

    image

    With the LookUp user-function

    image

    Using the test tool, we receive the following result:

    image

    The number of rows in "table1" is 2.

How to use SAP's WebAS J2EE's JMS Queue in Exchange Infrastructure

Do you know that the WebAS J2EE server also contains JMS queues you can use for XI scenarios? And, you don't have to license MQSeries or SonicMQ.

The queues can be created and configured using the J2EE Visual Adminstrator, and be used in JMS sender and receiver communication channels.

 

Creating a queue in the Visual Administrator:

  1. Navigate to Server -> Services -> JMS Provider
  2. Click on the "Default" service or create your own
  3. Click on the tab: Queues
  4. Clock on "Create" to create a queue

image

 

Create/Configure JMS sender and receiver communication channels:

  • JMS Sender Communication Channel:

    image

    Configurations:

    Transport Protocol:  Access JMS Provider with JNDI
    JNDI Lookup Name of QueueConnectionFactor:  jmsfactory/default/QueueConnectionFactory
    JNDI Lookup Name of JMS Queue:  jmsqueues/default/MyTestQueue (This is based on the path of the queue created in Visual Administrator.)
    Name of JNDI Initial Context Factory:  com.sap.engine.services.jndi.InitialContextFactoryImpl

     

  • JMS Receiver Communication Channel:

    image

    Configurations:

    Transport Protocol:  Access JMS Provider with JNDI
    JNDI Lookup Name of QueueConnectionFactor:  jmsfactory/default/QueueConnectionFactory
    JNDI Lookup Name of JMS Queue:  jmsqueues/default/MyTestQueue (This is based on the path of the queue created in Visual Administrator.)
    Name of JNDI Initial Context Factory:  com.sap.engine.services.jndi.InitialContextFactoryImpl

     

NOTE:  Unfortunate, there is no tool to view or administer the content of the queue.
Contrary to popular believe, the message or document sent thru XI does NOT have to be in XML format. This means that any data, including EXE, ZIP, PDF, Word, Excel, etc., can be sent thru XI from any adapter to any adapter. Provided, of course, the receiver system will be able to handle the data format. (File adapter is an example which can handle any format without any development.)

Not only that, in developing this interface, there is no need to create any objects in the Integration Repository (IR). This means no mapping. Yes, if the data is not in XML, then no mapping can be done. So, we will only need to work in the Integration Directory (ID).

What can we do with this knowledge? Here are some examples:

  1. we can test adapters very easily and quickly without any IR development.
  2. we can send any formatted data without having to convert it to XML and back again, e.g. file->XI->file.
  3. we can send any document from 1 sender to multiple receivers using XI to guarantee delivery.
Here are the steps required: (some steps will not contain any details because they are no different than developing for any other XI interfaces)
  1. Configure sender and receiver communication channels in a Business Service or System, as usual.
  2. Create a Receiver Determination:

    image

     

    1. The Service has to be a valid business service or system in the ID.
    2. Interface name can be anything you make up, but should be unique. In this case, it is "nonexistence_interface".
    3. Namespace name can be anything you make up or already exists. In this case, it is "http://abc.com".

     

  3. The following is created:

    image

    Enter a valid service for the Receiver and save.

     

  4. Create Interface Determination:

    image

     

    1. Use the same Interface name as the sender.
    2. Use the same Namespace name as the sender.
    3. Do NOT enter any Interface Mapping.

     

  5. Create Sender and Receiver Agreements as usual.
The interface is now ready to be activated and executed. Once executed, you can examine the content of the payload in SXMB_MONI. It will contain whatever the data you sent, but you will also receive an error indicating that the message is not XML (which can be ignored).


The main points of this exercise is:

  1. IR is not necessary for development of interfaces in XI.
  2. In ID, any name can be used for Sender Interface and Namespace names, and they do not need to exist in IR.
  3. No Mapping can be used, since the data may not be XML.
  4. The Receiver Interface and Namespace names must match that of the Sender Interface and Namespace names.
  5. Most importantly: the data sent thru XI does NOT have to be in XML; any data can be sent thru XI.
Hello everyone. In the development of an integration scenario, no matter what tool is used, we can expect to spend as much as 95% of the time in doing mapping and transformations. Consequently, it is crucial that we understand the mapping tool being used.

XI provides its own mapping tool, Message Mapping, in addition to allowing us to use standards such as XSLT and Java. As a GUI tool, simple mappings using the Message Mapping tool are very easy to accomplish. However, with more complex mapping and transformations, a deeper understanding of the tool will be necessary.

Introduction


The EPI351 hands-on session will discuss the more advanced features and functions of the Message Mapping tool. We will get under the hood to see how the elements are being represented internally, therefore, allowing us to manipulate the contents during transformation. Once understood, there is literally nothing that cannot be done using this tool.

We will discuss the concept of queues and contexts, which represents the XML structures during transformation. We will look at the standard functions that work with those queues and contexts. We will also discuss the debugging and testing features of the mapping tool.

Session Detail

The hands-on session consists of a brief lecture consisting mainly of the concept of queues and contexts with some of the related standard functions, and 2 exercises.

One exercise will deal with developing a mapping program using functions relating to queues and contexts.

The 2nd exercise will be a debugging exercise. You will be presented with a completed mapping, but not exactly correct (does not produce the right transformation) and with errors. Using the debugging tool of Message Mapping, you will find and correct the problem(s).

With the 2 different types of exercises, we hope to give everyone a taste of both development and maintenance of mapping programs.

I hope see you all there.

Hello everyone. XI is a development and configuration tool. Like any other tools, there are good ways and bad ways of using it. The result can significantly influence the resource utilization and performance of your interfaces, or even recoverability. Have you ever wondered what mapping would be best, Message Mapping, XSLT or java? How about synchrnous versus asynchrnous interfaces, when should I use each and how much system resources will be required? What should I avoid during the development of a mapping? What about ccBPM, what are some pitfalls I can avoid so that my process does not end up to be a resource hog?

Well, XI is a very flexible tools, what can be achieved depends on the knowledge of the developer. We hope this session will help in providing you with some of those knowledge.


Introduction

The EPI204 lecture session will give you some guidelines and pros and cons for the different implementation approaches and tools, which can be used within SAP NetWeaver Exchange Infrastructure for solving your integration challenges.

With those information, you will be able to develop more efficient and robust interfaces.

The lecture will contain 2 sections: Integration Scenario Patterns and Best Practices.

 

Section Detail

The 2 sections will consiste of the following details:

Integration Scenario Patterns:

  1. Synchronous versus Asynchronous Scenario
  2. Collection of Messages
  3. Split of Messages
  4. State full Processing - Integration Process
  5. Serialization
XI Best Practices
  1. Initial Data Load
  2. ALE Migration
  3. Avoiding Sync-Front-end Integration
  4. ccBPM Checklist
  5. Performance Improvements
  6. Adapter Specifics


I hope see you all there.

Hello everyone. We are again presenting an exciting conference with even more interesting and useful sessions than before, especially in the Process Integration (or Exchange Infrastructure) area. Of course, this is a totally biased opinion. I am sure the other tracks and sessions are just as exciting and informative ;-)


Introduction

The EPI350 hands-on session is going to lead you step-by-step on how to develop a J2EE adapter user-module. You will be able to use the steps given in the workshop on your own system when you go back. In addition, the code we used in class can easily be modified to accommodate your own need.

As we get more sophisticated in using XI, we start to contemplate all kinds of possibilities how we can process even more interesting interfaces. Some of these interfaces, at first glance, may appear to be impossible. But, with the help of user-modules, we will now have a gleam in our eyes which will say "humm...I think I can...".

Adapter user-module introduces capabilities to process messages which seemingly would not be possible. An example is using PGP to read an encrypt message, or to produce an encrypted message for your business partner.

We will also be using the Partner Connectivity Kit (PCK) during this workshop. PCK is a very powerful tool which can be use to test our user-modules without an XI system. Since PCK only requires a J2EE engine, therefore, small enough to be installed on our laptop, we can develop our user-module while travelling, e.g. on an airplane. Yes, your company will love this. You will now be working during all your waking hours, without having to be connected.

Workshop Detail

At the end of this workshop, you will:

  1. Understand the architecture of SAP XI Adapter Framework
  2. Use the NetWeaver Developer Studio to develop and deploy the adapter module
  3. Use PCK to test the adapter module
  4. Understand the requirement and steps during the development process
  5. Configure the adapter module in the adapter communication channel
  6. Monitor the adapter module processing in the RWB
To save time, we have pre-configured the PCK and the test interface to test the user-module. But, we have included these configurations in the handouts so that you can duplicate them on your own systems.


I hope see you all there.

XI provides a fertile ground for providing added value and to improve end-to-end integration process. Development for the enhancements of the integration software is still in an adolescent stage. The opportunity to provide software by independent software vendors is just starting.
 
XI, as an integral component of SAP NetWeaver, already provides a large customer base consisting of existing SAP customers worldwide. In addition, XI is a serious and very strong competitor in the integration arena for non-SAP to non-SAP B2B and A2A scenarios in companies without any existing SAP products.
 
Below are the primary areas where SAP partners can enhance the usage of XI:
  1. J2EE Adapter: Like most integration products, XI uses XML standards to process the messages. However, most data are not stored in XML format. This is why XI comes with a set of technical adapters, e.g. file, jdbc, jms, to handle the non-XML data. These technical adapters convert those external data in their native format into XML and vice versa. The technical adapters from SAP only cover a very small set of data formats being used. The vast majority of data structures remain "unconvertible". This is reason why many companies use an interim/intermediate data format to integrate with XI. such as file or database. This is not very efficient and, sometimes, error-prone and security-risky, and also increases production support and monitoring complexity.
     
    However, if an adapter is available to natively work with those external data structures and formats, this will increase significantly the development, support and maintenance of the integration process. Currently, the integration of the many external data in its native format is still vastly untapped.
     
    SAP&#146;s J2EE adapter, which abides by JCA 1.5 standard, can be developed using the SAP Adapter Framework (AFW). The AFW includes libraries to easily incorporate message processing into the existing XI environment, which includes message management, monitoring, alerting, configuration, persistency, etc.
     
  2. Application Content: In an integration project, probably 90% of the time is spent in the Integration Repository, defining data structures, interfaces and, especially, mappings.
     
    If these repository objects are available, then significant time and resources can be saved, thereby, decreasing the project implementation time and cost.
     
    Once the repository objects are developed, they can be imported into the Integration Repository and used. Modifications can easily be done to customize special company requirements.
     
    Today, much of development in the repository involves the integration of standard external interfaces (e.g. EDI) to IDoc and vice versa. There are still a vast number of structures with interfaces which are still being developed individually by each company.
     
  3. J2EE Adapter User-Modules: User-modules are java programs which are executed in the J2EE adapter, very similar to user-exits. Consequently, these user-modules can be used by any J2EE adapter through configuration in the Integration Directory.
     
    User-modules have been used to perform encryption/decryption of data, and transformation of data before/after the data is sent to/from the XI server.
     
    User-module can process messages generically in the J2EE adapter, meaning that it can be used by any adapter. Therefore, it can be extremely flexible.
     
    User-modules can be developed to handle a variety of situations currently not available with standard J2EE adapters.
     
  4. Integration Add-On for non-SAP software: All companies use non-SAP software, and the integration of the software to XI may not be suitably handled by developing new J2EE adapters or user-modules. It might be easier and more efficient to provide an add-on within the non-SAP software to integrate with XI. The integration might be incorporated as part of the usage of the software. The add-on provides a direct, behind-the-scene integration to XI.
     
    These integration add-ons might be webservices, which send specific data to XI to be integrated to SAP or other application/systems. Along with the add-on, there might be application contents required, e.g. defining the interfaces for the webservices and mapping/transformation programs.
     
The above only outlined four different areas where SAP partners can provide additional services to XI. There are still many other areas not discussed here.

Actions

Filter Blog

By date:
By tag: