SAP Community - NW ABAP Internet Communication Framework

The meaning of LIFETIME_RC

2004-10-12T10:34:40+02:00

Last week, during some preparation for my talk at TechEd on Thursday this week, I'd been wondering about something in the ICF that hadn't seemed quite right. Interface IF_HTTP_EXTENSION, which is what every ICF handler must implement (in the form of a single method HANDLE_REQUEST) has a couple of attributes, FLOW_RC and LIFETIME_RC. FLOW_RC is for controlling the flow of handler dispatching for a request. LIFETIME_RC is for controlling the lifetime of handlers for a sequence of requests. To quote the documentation at help.sap.com on the latter:

HTTP request handlers can control the lifetime of their instances if they are operating in stateful mode ... If the attribute IF_HTTP_EXTENSION~LIFETIME_RC is set to one of the following values, the HTTP request handler can specify whether the handler should be reinitiated for every request in a session, or whether the handler should be retained and reused for subsequent HTTP requests.

The default action is for the handler instance created to handle the request to be kept, so that instance-level data is retained (think of an incrementing counter value that keeps going up every new request). This is the equivalent of setting LIFETIME_RC to the value of the constant CO_LIFETIME_KEEP. But if LIFETIME_RC is set to the value of constant CO_LIFETIME_DESTROY:

The current instance of the HTTP request handler is terminated after the request is processed. If stateful mode is active, a new instance of the HTTP request handler is created. This means that local data belonging to the instance is lost.

[This of course only makes sense in the context of stateful sessions, which you can create using the SET_SESSION_STATEFUL method (of IF_HTTP_SERVER) - one effect of which causes a context id cookie to be constructed and set in the next HTTP response.]

Ok, so with the phrasing of the help text (such as "...can control the lifetime...") and the implication of the "DESTROY" part of the constant name, I did a little experiment to try and control the lifetime, by setting the LIFETIME_RC attribute so that the handler instance would be destroyed after it exited. Did it work as expected?

No.

Hmm. What's going on? Well, it seems that with LIFETIME_RC, it's either all or nothing. If you set your session to be stateful and specify that the handler instance should be kept (or let it default to that anyway), then you can't, later in the session, suddenly decide to have the session destroyed.

Looking under the hood, we see this is confirmed in the ICF layer's code. The whole process of handling a request is triggered via PBO modules in SAPMHTTP, and via the HTTP_DISPATCH_REQUEST coordinator, we come to the EXECUTE_REQUEST (or EXECUTE_REQUEST_FROM_MEMORY which I've seen in 6.40) method of the CL_HTTP_SERVER class.

When a request comes in, the appropriate handler is instantiated, and the HANDLE_REQUEST method called. Once this method returns, a decision based on LIFETIME_RC is made as to whether to save the instantiated handler object in an internal table, ready for a new request. Unless LIFETIME_RC is set to destroy, the object is saved, providing we're dealing with a stateful session:

if server->stateful = 1 and extension->lifetime_rc = if_http_extension=>co_lifetime_keep and ext_inst_idx = -1. * add extension to list of instantiated extensions ...

There's no facility for removing existing table entries though. And this is the key to understanding why manipulating the LIFETIME_RC attribute won't always do ... what you think it should do.

I bet you're glad you know that now ... share and enjoy 🙂

Identify the owner of the process holding the mutex lock

2018-12-19T12:39:38+01:00

Purpose

To identify the process holding the mutex lock which will help in troubleshooting mutex related problems.There are different processes holding the mutex lock.In order to identify which is that process and how to release that held mutex we must first understand how to identify the process.

Breaking down the MtxLock

Firstly what is meaning of the MtxLock function ? By definition this means wait for a lock to become available. Mutexes can't be recovered automatically if a process dies while still holding a lock.

The Mutex related trace entries

In the developer traces of the work processes (dev_w*) we can find the entries as:

example #1

*** WARNING => MtxLock <hex address> RQ_Q_WOD owner=30004 deadlock ? [mtxxx.c 641]

example #2

*** WARNING => MtxLock <hex address> MTXGLOB owner=30001 deadlock ? [mtxxx.c 2574]

Now lets break down each example one by one.

From example #1

*** WARNING => MtxLock a00010020000270 RQ_Q_WOD owner=30004 deadlock ? [mtxxx.c 641]

Now here we can see the owner is : owner=30004

Similarly in example #2 we can see the owner is owner=30001

Identifying the caller id aka client id aka CID

First I would like to list out the predefined client id's in the kernel.

The Client id range starts from 30000 and is end to 32767.

By definition it states as ( part of internal SAP coding I cant provide more detail due to security reasons ) :

30000+0 = 30000 --> Owner is dispatcher

30000+1 = 30001 --> Owner is ICM

30000+2 = 30002 --> Owner is the java control process

30000+3 = 30003 --> Owner is dpmon process

30000+4 = 30004 --> Owner is gateway

30000+5 = 30005 --> Owner is VMC process

30000+6 = 30006 --> Owner is ES (extended segment) memory area

30000+7 = 30007 --> Owner is EM (extended memmory) memory area

30000+8 = 30008 --> Owner is EM (extended global) memory area

Troubleshooting the entries

Going one step further we now know who is the owner of the mutex.Our next step is checking the related developer trace file to rectify the issue.

From example #1

*** WARNING => MtxLock <hex address> RQ_Q_WOD owner=30004 deadlock ? [mtxxx.c 641]

Here we will check in the gateway trace (dev_rd) to see what is the issue.

From example #2

*** WARNING => MtxLock <hex address> MTXGLOB owner=30001 deadlock ? [mtxxx.c 2574]

Here we will check in the ICM (dev_icm) to see what is the issue.

TIP: Please also check the dev_*.old traces respectively.

Let me know in case any queries.

Kind regards,

Manjunath Hanmantgad

SICF on PI/PO single stack : Shortening Long URLs for customers inbound.

2018-12-20T12:46:01+01:00

SICF alternative on PI/PO single stack.

In case where customer sends us files on a dual stack, SICF is available to create service and shorten the long technical URLs with various security mechanisms.

Which means something like this

{server:port}/HttpAdapter/HttpMessageServlet?interfaceNamespace=<namespace> &interface=<interface name>&senderService=BS_Sender&qos=EO

can be made to this

{server:port}/<context-root>/<app>

without compromising on the authentication mechanism like Basic, certificate etc. in PI/PO .

The 'test' service in the below pic

can be accessed using

https://<server>/<service element>/test?sap-client=300

Logon is a list of Logon Procedure in that order to be followed.

However On Java stack where we no more have such a service, the same can be achieved by using a servlet which will forward the received request to the HTTP adapter URL.

{server:port}/HttpAdapter/HttpMessageServlet?interfaceNamespace=<namespace> &interface=<interface name>&senderService=BS_Sender&qos=EO

The customer actually posts to the servlet, which then forward it to the Http Adapter. This method can be used in other scenarios as well where we need to shorten a url or don't want the outside world to know about the technical details.Below is the procedure:

Procedure:

In NWDS, create two DCs of type WebModule & Enterprise Application in DI perspective.

Give a name for the project , here “sicf”.

Chose Finish

Create DC of type Enterprise Application

Link with the webmodule “sicf”

Choose Finish .

In the Project Explorer , select the Dynamic Web Project.

In the context menu, choose New → Servlet .

Throughout the wizard pages, enter the servlet settings as required.

Here we created a class named “test” in the java package “com.test”

To access the servlet, you need to add servlet mapping. Using this and the context-root specified in application.xml we will be able to access the URL. Each mapping represent a java class here test.java can be accessed using /test in the browser (GET method) or UI tools.

Here we select the doPost and doGet methods where we will write our code.

Chose Finish

You can see that in the project structure Servets, Its Mapping and the Java class has been created.

Inside test.java , the doGet & doPost needs to be implemented.

Copy paste the below code. The Get method will just print out some message. The post method will redirect the request to the Http adapter .

/**

	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)

	 */

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		PrintWriter out= response.getWriter();

		out.println("This is the GET Method ,use POST to post data ");

		

	}



	/**

	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)

	 */

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		PrintWriter out= response.getWriter();

		

		ServletContext web1 = getServletContext();;

		ServletContext web2 = web1.getContext("/HttpAdapter");

		RequestDispatcher rd = 

		web2.getRequestDispatcher("/HttpMessageServlet?interfaceNamespace=urn:sap-com:document:sap:idoc:messages&interface=GSVERF.GSVERF01&senderService=SELFBILLING&qos=EO");

		

		rd.include(request, response);

		out.println("Response -> Inside Post method");

		out.close();

	}

Servlets can redirect client requests to other servlet and JSP components. This is done by using the “include” method of the request dispatcher as seen above in the doPost method.

For authentication we need to maintain web-descriptors , namely web.xml and web-j2ee-engine.xml in our application.

In web-j2ee-engine.xml, we need to enter the security mechanism to be used.

<login-module-stack> can have multiple <login-module> elements.

<?xml version="1.0" encoding="UTF-8"?>

<web-j2ee-engine xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="web-j2ee-engine.xsd">

	<spec-version>2.4</spec-version>

	<security-role-map>

 		<role-name>Everyone</role-name>

 		<server-role-name>Everyone</server-role-name>

 	</security-role-map>

  <login-module-configuration>

  	<login-module-stack>

  	<login-module>

  	<login-module-name>BasicPasswordLoginModule</login-module-name>

  	<flag>REQUIRED</flag>

  	</login-module>

  	

   	</login-module-stack>

 </login-module-configuration>

</web-j2ee-engine>

The element <login-module-name > can be found in NWA path:

NWA-> Configuration->Security->Authentication & SingleSign-On

The element <flag> can be :

In the web.xml descriptor , there is an entry for servlet and its URL mapping

Include below code for the login mechanism after <servlet-mapping> node ends, we are using client-cert and basic. The role mapped here is the j2ee role and not PI.

<security-role>

		<description>Everyone</description>

		<role-name>Everyone</role-name>

	</security-role>

	<security-constraint>

		<web-resource-collection>

			<web-resource-name>General access restriction</web-resource-name>

			<url-pattern>/*</url-pattern>

		</web-resource-collection>

		<auth-constraint>

			<description>EveryoneH</description>

			<role-name>Everyone</role-name>

		</auth-constraint>

		<user-data-constraint>

			<transport-guarantee>NONE</transport-guarantee>

		</user-data-constraint>

	</security-constraint>

	<login-config>

		<auth-method>BASIC,CLIENT-CERT</auth-method>

		<realm-name>test</realm-name>

	</login-config>

Multiple mechanism , If used , should be comma separated.

The sub-element auth-method configures the authentication mechanism for the web application. The element content must be either NONE, BASIC, DIGEST, FORM, or CLIENT-CERT. The realm-name element indicates the realm name to use when the basic authentication scheme is chosen for the web application.

In the EAR project create application.xml file.

The application.xml links the war file to the context-root that helps us give application a name.

Using the context-root our URL to access test.java is

<server>:<port>/<context-root>/<servlet-url-mapping>

i.e.

<server>:<port>/sicftesting/test

<?xml version="1.0" encoding="UTF-8"?>

<application 

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

xmlns="http://java.sun.com/xml/ns/javaee" 

xmlns:application="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/application_5.xsd" version="5">

  <display-name>SICFTest</display-name>

  <module>

    <web>

      <web-uri>demo.sap.com~sicf.war</web-uri>

      <context-root>sicftesting</context-root>

    </web>

  </module>

</application>

Build both the application and EAR and deploy.

Finally, as your application is on the server ,you can use a browser to call the application - the doGet method will be called. The output below is what we wrote in the doGET method.

Use tool like Postman or SoapUI to send the request/file and you will find an entry in your pimon tool.

Below is the scenario which got triggered after sending the request .

So ,as our HTTP adapter is itself implemented as a servlet , we create another servlet to redirect inbound requests to this adapter masking all the technical details with all the security mechanisms in place, making it easier for the partners to use and we can internally change the landscape , interfaces without the need to to communicate the change making task a lot easier.

Please feel free to comment , suggest and ask any questions.

Updated on 21st Dec 2018 :

Forgot to mention ,that as we have the HttpServletRequest request & HttpServletResponse response objects in the function call , they can be used to manipulate query or header parameters as well as the response codes .

Example:

//for all the query params 

request.getQueryString();



//username=james&password=pwd

request.getParameter("username");

Invalidating Cache is not working.Entries in ICM trace as "IctICmRemoveFile() failed. 1"

2019-01-29T12:08:52+01:00

Purpose

While trying to invalidate cache I was constantly being faced by the issue that post invalidating the cache, my screen was turning blank or it was giving me with the blank page.

Once I invalidated my cache it would work for some time (approx 10 minutes) but again when I executed the URL I would get a blank page again.

Troubleshooting

The first thing that came to my mind when I came across this issue was to check in icm trace file ( dev_icm ).

In icman trace file I could see the entries as:

*** dev_icm

[Thr 15696] Fri Jan 25 14:21:44 2019
[Thr 15696] *** ERROR => remove('\\*\sapmnt\<SID>\ASCS00\data\cache\M0x1AC4') failed. errno=2 [ictxxcache_r 4331]
[Thr 15696] *** ERROR => ENOENT*: No such file or directory OR: The system cannot find the file specified. [ictxxcache_r 4333]
[Thr 15696] *** ERROR => IctICmRemoveFile() failed. 1 [ictxxcache_r 3369]
[Thr 15696] *** ERROR => can't write resource '/sap/public/bsp/sap/system/E9207E7015E6D2F18F8EA41F72C7461F&en&&GZ=0&000&A6E90000&' (
[Thr 15696] WARNING: ISC object '/sap/public/bsp/sap/system/E9207E7015E6D2F18F8EA41F72C7461F&en&&GZ=0&000&A6E90000&' not found

Based on the error entries the important functions that we need to check are ENOENT , IctICmRemoveFile , can't write resource , ISC object.

From the above entries at the first instance we can start to visualize that there is something wrong in the header of the url.

The entry : ERROR => remove('\\*\sapmnt\<SID>\ASCS00\data\cache\M0x1AC4') failed. errno=2 [ictxxcache_r 4331] ..proves this .

I tried to check if some application is causing this? After some research I came to know the issue is something different.

The entry : ERROR => ENOENT*: No such file or directory OR: The system cannot find the file specified. [ictxxcache_r 4333]

this indicates that cache directory which is been set is not actually being taken. In other words it is WRONG!

My next guess was to identify which parameter is related to cache directory and ICMan. Till now I was just trying get to understood what went wrong , but now I had the solution 😉

The parameter that is related to cache dir and icman is "icm/HTTP/file_access_<xx>".

If you look closely the standard value for this parameter is :

icm/HTTP/file_access_0 = PREFIX=/sap/public/icmandir/ ,DOCROOT=$(DIR_ICMAN_ROOT)

Here the point of concern is "DOCROOT=$(DIR_ICMAN_ROOT)".

Next I checked the value for $(DIR_ICMAN_ROOT). This was the important step which resolved my issue.

In icm/HTTP/file_access_0 I had set the DOCROOT to some other value which was not matching with ' DIR_ICMAN_ROOT '.

Once I changed the value of 'DOCROOT' in the 'icm/HTTP/file_access_0' the issue got resolved. I was able to proceed further without the irritating BLANK PAGE!!

Let me know if any queries.

PS: I would like to also point out to a fact that always check the below set of parameters :

ABAP-only or dual stack ( system/type = ABAP| DS )

Java-only ( system/type = J2EE )

Kind regards,

Manjunath Hanmantgad

Developing GraphQL API on ABAP: The Inspiration

2019-09-18T09:08:38+02:00

This two-part article will discuss details we need to know about the GraphQL implementation in SAP ABAP. How it was born, what it offers, and how to use it. As this is my first blog post ever and I am not an expert in either ABAP or GraphQL, the article may contain few mistakes. Also, this article is not designed to be a comparison of REST or OData vs GraphQL.

For those wants to skip to Technical details can go to part 2.

As I was looking for better ways to expose existing data in SAP through APIs which helps development and maintenance times low. I have tried a few ways to produce APIs out of SAP.

Earlier being ICF Services exposing data using ABAP to JSON converter utility (custom) classes. Which were bare minimum implementations of APIs that can be exposed out of SAP using SICF. Which is equivalent of Express Server in NodeJS world.

Although ICF services are quite powerful and provide total control over what can be sent over responses, I continued looking further for better options.

GraphQL

As I also work with NodeJS to develop Web Applications and Server-Side APIs, I have been following GraphQL from its earlier stages since Facebook has made it public and I am very much fascinated by the way GraphQL standardizes the access of our backend Relational Data.

Although this article is not in any way the introduction to GraphQL, I would like to just talk about a few features it brings to the table.

The quote from https://graphql.org, Describe your data, Ask for what you want and Get predictable results provides all there is to know about GraphQL in a nutshell.

One of the advantages I love about GraphQL is the ability to traverse through the relationships of our Data model. Which provides superpowers to the clients requesting data and puts totally in charge. This makes sense in the multi-platform world that A mobile App can choose to fetch fewer data from the same API endpoint as opposed to a Web Application which has more screen area.

Request and Response to GraphQL Server (image from https://www.howtographql.com)

Another advantage of GraphQL which simplifies API development and maintenance is that we can get rid of versioning APIs and maintaining several endpoints and flavors of the same domain data. As GraphQL provides Queries (Read), Mutations (Create, Update and Delete) and Subscriptions (Real-time Updates) all under single endpoint, scaling and maintaining is much simpler. Instead of versioning API, GraphQL has the functionality to flag fields for Depreciation along with the reason. Adding new fields will not be affecting existing API unless clients request for it.

The GraphQL Type System will provide the Documentation by default so that the consumers are well aware of what to request and expect back from the Server.

As the popularity of GraphQL increases, so are the Tools and Libraries around it. The GraphQL community is really awesome and can find a lot of resources online for learning about it.

The GraphiQL tool is one used to interact with GraphQL server and has several flavors to improve usability. GraphiQL provides auto-completion of queries and shows the documentation from Server.

Apollo and Relay libraries provide easy to integrate GraphQL into the development workflow

SAP

I would like to mention about SAP CRM module as well here, as my end goal is to expose CRM customer data as APIs. CRM has divided the functionality into Business Partners and One Order, which is already exposed to CRM UI with the help of BOL(Business Object Layer)/GenIL(Generic Interaction Layer). My Idea is to leverage what has been working for several years and extend to expose as a GraphQL API.

If we look closely, BOL/GenIL has several similarities with GraphQL.

BOL defines Advanced Search Entities which can be related to Query Types in GraphQL

Query Parameters can be converted as Arguments

Root Entities/ Result Entities can be related to Custom Types

Each attribute of the Entity can be exposed as Type fields

Each consequent relation can be considered as Related/Sub Types and can be resolved with getRelatedEntitie(s) function calls of GenIL

Data Element values or Value Tables for each BOL field can be converted as Enum

Last but not least, GenIL Create Entity, Update Entity and Delete Entities can be mapped to Mutations

This view of mapping from BOL/GenIL to GraphQL compelled me to invest more time in building the GraphQL server to expose as a unified interface into SAP CRM.

Initially, I have started to implement GraphQL in NodeJS and call custom REST endpoints into SAP. Even though this approach allowed me to build an initial Proof of concept. I am not convinced that simply calling REST endpoints behind GraphQL NodeJS implementation and applying filters outside SAP, is a huge task and we can not fully leverage features BOL/GenIL. I feel that it's just a hack to expose data from SAP.

I have started looking into GraphQL implementation in ABAP and failed to find one at the time I started building one myself (around Jan 2018). I took the code of Java implementation as a reference in building GraphQL server within ABAP. There has to be a lot of adjustments and sacrifices in porting the Java code to ABAP, as ABAP OOPs is slightly different and I need to strip out Threading as our SAP ICM(Internet Communication Manager) will manage this for us at the request level in my understanding. Also changed the implementation to work with the idea of loading config from tables instead of Schema files as in other languages.

Once the GraphQL server is built and ready in ABAP, It was easy to expose BOL/GenIL to the server as reading from Config tables already available in SAP CRM.

Enough of the story, we shall now dive into technical stuff in this second part of the Article.

Developing GraphQL API on ABAP: Architecture and Technical Details

2019-09-19T10:04:04+02:00

This article is the second in series, explains the technical details and includes few screenshots to give a preview. If you want to read some background and boring stuff, is covered in the first part.

Before going to the details, a few product vision key features I have considered.

Leverage what SAP/ABAP has to offer most. ex. ICM, OOPs

Modularize the implementation
- Independent JSON converters
- GraphQL Service Handler knows nothing about the schema
- Resolvers can be independent of Schema generation logic

BOL Resolvers to generate Dynamic schema and resolve all CRUD operations using GENIL operations

Schema can be saved to Database Tables to be re-loaded/configured manually

SAP Sessions to improve performance with BOL and retaining Schema across requests

Testable Code and ABAP Test Scripts for code coverage

Architecture

Architecture Diagram

GraphQL server is exposed as an ICF service from ABAP, which accepts and provides JSON data

ICF handler class takes JSON string and convert to ABAP GraphQL Schema classes and validated

Schema is built only for the first time if the Session is enabled

The user input Query will be parsed and the Execution Context is created

Resolver class will be called for individual resolver identifications

Resolver will either go to BOL/GenIL or APIs or can directly talk to DB to fetch data

Data will be submitted back to ExecutionContext as JSON classes

Finally, JSON classes will be validated and converted to JSON string as ICF service response

Accessing the API

Note: currently this is under active development, watch this space for updates and code

MYSAPSSO2 token for authentication

Follows standard SAP authorization like MYSAPSSO2 header/cookie in the Request.

API Documentation

GraphQL API provides API documentation by default and can be accessed using Schema Queries. Which will provide information to frontend team to browse through the contract to know what fields/operations are supported by the API

Queries — using BP Advanced Search

Query is the way to get some data from API, which is same as HTTP “GET” operations. Query can have Arguments which will help filter the results from the API. Query should end with requesting necessary field by the UI.

BP Advanced Search Results

Here we can see the Results as sent back from API, which exactly matches the Requested 4 fields from the server.

Mutations — Creating BP with Deep Data

Mutations are a way to change some data on the server. Here we are creating a BP along with the child relations like Address and Marketing Attributes.

Mutations — Creating Child data of BP

Mutations — Updates and Deletes

At a Glance

Packages

ZGRAPHQL — Main Package

ZGRAPHQL_LANG — contains all the Language/Schema Implementation classes

ZGRAPHQL_API — contains base Service classes to expose CRM data as API

ZGRAPHQL_CORE — Base Server Classes

Message Class — ZGRAPHQL

Important Classes

ZGQLSCL_SCHEMA

responsible for creating the GraphQL Schema (Type System)

can create either from Internal Tables or from Database Tables

Validates and Creates Schema Object

loads all required components into Memory

Builds Introspection Resolver and Holds User Resolver

ZGQLCL_API_SERVICE_BASE

Base SICF handler class to handle basic functionality of the GraphQL server

All Sub-classes are only expected to provide Schema from PREPARE_SCHEMA method

ZGQLCL_TABLES_RESOLVER

which builds Schama using given ABAP table names

ZGQLCL_BUIL_GENIL_RESOLVER

Class to resolve all Business Partner related BOL operations

ZGQLCL_BUIL_CUST_RESOLVER is a specialization which allows restricting

BOL entities and Relationships exposed

Mapping for the Relationship names

ZGQLSIF_RESOLVER

Resolver to provide links to Operation and Data

All Implementation classes must provide

Schema to be initiated

Resolving Method for each Operation

ZGQLSCL_INTROSPEC_RESOLVER

responsible for resolving Schema Introspection queries

ZCX_GQL_EXCEPTION

Base Exception class available globally to throw Errors

The server automatically handles this error and passes to Client as “errors” array in response

can handle BOL errors and BAPI errors

ZGQLCL_EXECUTION_CONTEXT

the class is responsible for keeping the current Context until the end of the operation execution

Validates the current Operation submitted by Client before starting the execution

holds Schema, Operation currently being executed, Selections requested by Client

ZGQLCL_EXECUTOR

the class is responsible for executing Query, Mutations and handle Errors

EXECUTE_QUERY

the method resolves Query operations

2. EXECUTE_MUTATION

the method performs Mutation (update) operations

3. EXECUTE_SELECTION_SET

method to resolve each field requested by the Client

recursively resolves each Custom Type until it reaches Leaf Nodes

ZGQLCL_LOG

used for logging the requests to the GraphQL server

logs Request Operations, Response Errors

Transaction: SLG0, Object — ZGRAPHQL, Sub Object — ZGQL_GEN

ZGQLCL_UTILS

utility functions for reading AppSet Entries and Domain Values

The benefits I observe from this approach are:

Higher Abstraction of the API Implementation

Easy Integration using widely popular toolchain on UI running outside SAP

Above all, Performance can be tweaked within SAP as we run the logic near Database

Even though I started this as an exploring project not knowing if I could finish it on my own or not, spending my evenings and holidays, After seeing the final result, I requested my Manager to spend some time for a small the Demo.

Having no expectations, with the CRM experience my Manager immediately identified the potential of this solution and the advantages our Organization can get in exposing CRM data using GraphQL. With his support, I have managed to present to higher management.

And today we are experimenting and building unified enterprise level services for multiple Web Applications with minimal friction and with High performance. The feedback from the Web developers is that 'Fast development times, Ease of use and more options in choosing client libraries'.

Logging incoming requests when creating short URLs

2020-01-14T14:40:02+01:00

Based on my previous blog - SICF on PI/PO , We may need to log incoming requests or process the incoming requests (e.g delete few header /prolog etc.) as per our needs before sending it to the adapter.

But the challenge here is you cannot in anyway touch the actual request - the moment you do it - the stream will be all used up and nothing will be forwarded to Adapter resulting in an exception.

This challenge can be mitigated by making a copy of the request first and then using a wrapper to access the content.

The wrapper can also be used to read the content and ignore the request or else strip some unwanted data from it and then pass on the adapter .

Here after stripping the unwanted content and extracting the xml -it is posted to the adapter.

The Loggers are used to log data in debug mode and can be viewed in /nwa/logs

The resetInputStream changes the content to the xml and we forward the wrapper instead of the actual request.

If you are not OK with the content you can send back a custom response like here 406

Here I show you an example with OAGI format which sends a Prolog sort of text before actual xml.

The xml starts after the string "Payload="

(PS: I am using fasterjackson library to convert objects into string)

The servlet with doPost

package com.mycompany;



import java.io.IOException;

import java.io.PrintWriter;

import java.util.logging.Logger;



import javax.servlet.RequestDispatcher;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;



import com.mycompany.logging.entity.LoggingRequest;

import com.mycompany.logging.wrapper.LoggingHttpServletRequestWrapper;

import com.mycompany.logging.wrapper.LoggingHttpServletResponseWrapper;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.sap.tc.logging.Configurator;

import com.sap.tc.logging.Log;

import com.sap.tc.logging.Severity;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;







/**

 * Servlet implementation class 

 */

public class oagi extends HttpServlet {

	

	private static final long serialVersionUID = 1L;

	  

	private static final com.sap.tc.logging.Location LOGGER = com.sap.tc.logging.Location.getLocation(oagi.class);

	ObjectMapper ObjectMapper = new ObjectMapper();

	

	/**

     * @see HttpServlet#HttpServlet()

     */

    public oagi() {

        super();

       

        // TODO Auto-generated constructor stub

    }



	/**

	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)

	 */

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		LOGGER.entering();

		

		response.getWriter().append("Served at: ").append(request.getContextPath());

		LOGGER.exiting();

	}



	/**

	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)

	 */

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		LOGGER.entering("doPost");

			

		//PrintWriter out= response.getWriter();

		ServletContext web1 = getServletContext();

		ServletContext web2 = web1.getContext("/HttpAdapter");

	

		//send to adapter

		RequestDispatcher rd = 

		web2.getRequestDispatcher("/HttpMessageServlet?interfaceNamespace=http://OAGI/test&interface=SI_OrderRequest_OutS&senderService=BC_EU_Orders_OAGI&qos=BE");

		

		HttpServletRequest httpRequest = (HttpServletRequest) request;

		HttpServletResponse httpResponse = (HttpServletResponse) response;



		LoggingHttpServletRequestWrapper requestWrapper = new LoggingHttpServletRequestWrapper(httpRequest);

		

		

			String content = requestWrapper.getContent();

			

			String	searchit = "PAYLOAD=";

			

			if(!content.isEmpty()) 

			{

				

				if(!(content.startsWith("<")))

				{

					LOGGER.debugT("original content : " + content);		

					int off = content.indexOf(searchit);

					if(off != -1)

					{

						off = off + searchit.length();

						content = content.substring(off);

						LOGGER.debugT("Stripped content : " + content);			

						requestWrapper.resetInputStream(content);

					    content = null;

				    

					    LOGGER.exiting("doPost" );

					    rd.forward(requestWrapper, response);

					}

					else

					{

						LOGGER.errorT("REQUEST: " + getRequestDescription(requestWrapper) +"Content:" +content );

					    

					    httpResponse.reset();

					    httpResponse.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE); //send 406

					    httpResponse.setHeader("Location", requestWrapper.getLocalAddr());

					    return;	

					}

				}

				else 

				{

					content = null;

				    LOGGER.exiting("doPost" );

				    rd.forward(requestWrapper, response);

				}

				

				return;

			}

		

		

		

	}

	

	

	

	protected String getRequestDescription(LoggingHttpServletRequestWrapper requestWrapper) {

		LoggingRequest loggingRequest = new LoggingRequest();

		loggingRequest.setSender(requestWrapper.getRemoteAddr());

		loggingRequest.setMethod(requestWrapper.getMethod());

		

		loggingRequest.setUser(requestWrapper.getRemoteUser());

		loggingRequest.setParams(requestWrapper.isFormPost() ? null : requestWrapper.getParameters());

		loggingRequest.setHeaders(requestWrapper.getHeaders());

		

		//String content = requestWrapper.getContent();

		

		//loggingRequest.setBody(content);

		



		try {

			return ObjectMapper.writeValueAsString(loggingRequest);

		} catch (JsonProcessingException e) {

			LOGGER.warningT("Cannot serialize Request to JSON"+ e.getMessage());

			return null;

		}

	}



}

Sample Request Wrapper (most of the methods are not used)

package com.mycompany.logging.wrapper;



import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.UncheckedIOException;

import java.nio.charset.StandardCharsets;

import java.util.Arrays;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.stream.Collectors;



import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;



import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;



import com.mycompany.logging.OAGIFilter;



public class LoggingHttpServletRequestWrapper extends HttpServletRequestWrapper {



	private static final com.sap.tc.logging.Location LOGGER = com.sap.tc.logging.Location.getLocation(LoggingHttpServletRequestWrapper.class);

	

	private static final String FORM_CONTENT_TYPE = "application/x-www-form-urlencoded";



	private static final String METHOD_POST = "POST";



	private byte[] content;



	private final Map<String, String[]> parameterMap;



	private final HttpServletRequest delegate;

	private LoggingServletInputStream servletStream;

		

	

	

	public LoggingHttpServletRequestWrapper(HttpServletRequest request) {

		super(request);

		this.delegate = request;

		this.servletStream = new LoggingServletInputStream();

		

		if (isFormPost()) {

			this.parameterMap = request.getParameterMap();

		} else {

			this.parameterMap = Collections.emptyMap();

		}

	}



	public void resetInputStream(String content) {

		this.content = content.getBytes();

		

		LOGGER.debugT("content : " + new String(this.content));	

	    

		servletStream.is = new ByteArrayInputStream(content.getBytes());

	}

	

	@Override

	public ServletInputStream getInputStream() throws IOException {

		

		if (ArrayUtils.isEmpty(content)) {

			return delegate.getInputStream();

		}

		LOGGER.debugT("inputstream content : " + new String(this.content));	

		return new LoggingServletInputStream(content);

	}



	@Override

	public BufferedReader getReader() throws IOException {

		if (ArrayUtils.isEmpty(content)) {

			return delegate.getReader();

		}

		return new BufferedReader(new InputStreamReader(getInputStream()));

	}



	@Override

	public String getParameter(String name) {

		if (ArrayUtils.isEmpty(content) || this.parameterMap.isEmpty()) {

			return super.getParameter(name);

		}

		String[] values = this.parameterMap.get(name);

		if (values != null && values.length > 0) {

			return values[0];

		}

		return Arrays.toString(values);

	}



	@Override

	public Map<String, String[]> getParameterMap() {

		if (ArrayUtils.isEmpty(content) || this.parameterMap.isEmpty()) {

			return super.getParameterMap();

		}

		return this.parameterMap;

	}



	@Override

	public Enumeration<String> getParameterNames() {

		if (ArrayUtils.isEmpty(content) || this.parameterMap.isEmpty()) {

			return super.getParameterNames();

		}

		return new ParamNameEnumeration(this.parameterMap.keySet());

	}



	@Override

	public String[] getParameterValues(String name) {

		if (ArrayUtils.isEmpty(content) || this.parameterMap.isEmpty()) {

			return super.getParameterValues(name);

		}

		return this.parameterMap.get(name);

	}



	public String getContent() {

		try {

			if (this.parameterMap.isEmpty()) {

				content = IOUtils.toByteArray(delegate.getInputStream());

			} else {

				content = getContentFromParameterMap(this.parameterMap);

			}

			String requestEncoding = delegate.getCharacterEncoding();

			String normalizedContent = StringUtils.normalizeSpace(new String(content, requestEncoding != null ? requestEncoding : StandardCharsets.UTF_8.name()));

			return StringUtils.isBlank(normalizedContent) ? "[EMPTY]" : normalizedContent;

		} catch (IOException e) {

			throw new UncheckedIOException(e);

		}

	}

	

	

	



	private byte[] getContentFromParameterMap(Map<String, String[]> parameterMap) {

		return parameterMap.entrySet().stream().map(e -> {

			String[] value = e.getValue();

			return e.getKey() + "=" + (value.length == 1 ? value[0] : Arrays.toString(value));

		}).collect(Collectors.joining("&")).getBytes();

	}



	public Map<String, String> getHeaders() {

		Map<String, String> headers = new HashMap<>(0);

		Enumeration<String> headerNames = getHeaderNames();

		while (headerNames.hasMoreElements()) {

			String headerName = headerNames.nextElement();

			if (headerName != null) {

				headers.put(headerName, getHeader(headerName));

			}

		}

		return headers;

	}



	public Map<String, String> getParameters() {

		return getParameterMap().entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> {

			String[] values = e.getValue();

			return values.length > 0 ? values[0] : "[EMPTY]";

		}));

	}



	public boolean isFormPost() {

		String contentType = getContentType();

		return (contentType != null && contentType.contains(FORM_CONTENT_TYPE) && METHOD_POST.equalsIgnoreCase(getMethod()));

	}



	

	private class ParamNameEnumeration implements Enumeration<String> {



		private final Iterator<String> iterator;



		private ParamNameEnumeration(Set<String> values) {

			this.iterator = values != null ? values.iterator() : Collections.emptyIterator();

		}



		@Override

		public boolean hasMoreElements() {

			return iterator.hasNext();

		}



		@Override

		public String nextElement() {

			return iterator.next();

		}

	}



	private class LoggingServletInputStream extends ServletInputStream {



		private  InputStream is;



		private LoggingServletInputStream() {

			

		}

		

		private LoggingServletInputStream(byte[] content) {

			this.is = new ByteArrayInputStream(content);

		}



		public boolean isFinished() {

			return true;

		}



		public boolean isReady() {

			return true;

		}



		



		@Override

		public int read() throws IOException {

			return this.is.read();

		}



		@Override

		public void close() throws IOException {

			super.close();

			is.close();

		}

	}

	

	

	 }

Logging Request

package com.mycompany.logging.entity;



import java.io.Serializable;

import java.util.Map;



public class LoggingRequest implements Serializable {



	private static final long serialVersionUID = -4702574169916528738L;



	private String sender;



	private String method;



	private String user;

	



	private Map<String, String> params;



	private Map<String, String> headers;



	private String body;



	public String getSender() {

		return sender;

	}



	public void setSender(String sender) {

		this.sender = sender;

	}



	public String getMethod() {

		return method;

	}



	public void setMethod(String method) {

		this.method = method;

	}



	public String getUser() {

		return user;

	}



	



	public void setUser(String user) {

		this.user = user;

	}



	public Map<String, String> getParams() {

		return params;

	}



	public void setParams(Map<String, String> params) {

		this.params = params;

	}



	public Map<String, String> getHeaders() {

		return headers;

	}



	public void setHeaders(Map<String, String> headers) {

		this.headers = headers;

	}



	public String getBody() {

		return body;

	}



	public void setBody(String body) {

		this.body = body;

	}

}

Example : Error logged in /nwa/logs when payload had some irregular data:

Sample wrong payload

Sample unacceptable response

Here the request processing takes place in the doPost method itself - alternatively you can create a Filter in the project and use that to process the request.

Hope this would be helpful !

Now get target server root certificate in the comfort of your own browser without getting your local IP white-listed

2020-01-15T06:27:09+01:00

My obsession with this new way of hitting the PI server using servlets took new turn when a brilliant colleague of mine wanted me to program a way to get target root certificate without having to ask them for or without running a command on your cloud which is harder to access.

And now get the target server root certificates without getting your local IP white-listed ,in the comfort of your own browser, through PI server. (Of course, your server should be able to access the target)

It takes the URL as a query parameter and will print out the full chain of certificates and also write the root certificate which you can trust in your keystore in. CER format

Here is a sample for google

Scroll down to get X509 Certificate as .CER:

Here is the snippet which does the job for you.

To build the servlet you can always refer to SICF on Pi/PO

To enable logging you can refer to Logging Incoming Requests

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {



		try 

		{

			String url = request.getParameter("url");

			final String LINE_SEPARATOR = System.getProperty("line.separator");

			

			

			HttpsURLConnection connection = (HttpsURLConnection) new URL(null,url,new sun.net.www.protocol.https.Handler()).openConnection();

			connection.setRequestMethod("GET");

			connection.connect();

			

			Certificate[] certs = connection.getServerCertificates();

			for (Certificate cert : certs) {

			 

			  

			  response.getWriter().append("Certificate is : " + cert);

			}

			 

			 if (certs == null || certs.length == 0 || (!(certs[0] instanceof X509Certificate))) {

				    throw new SSLPeerUnverifiedException("No server's end-entity certificate");

				  }

			 

			 X509Certificate x509cert = ((X509Certificate) certs[0]);

			

			 Base64.Encoder encoder = Base64.getMimeEncoder(64, LINE_SEPARATOR.getBytes());

			 String cert_begin = "-----BEGIN CERTIFICATE-----\n";

			 String end_cert = "\n-----END CERTIFICATE-----";

			

			 byte[] derCert = x509cert.getEncoded();

			 

			 String pemCertPre = new String(encoder.encode(derCert));

			 String pemCert = cert_begin + pemCertPre + end_cert;

			 

			 

			 

			 response.getWriter().append("X509 Certificate in encoded form : \n").append(pemCert);

			 

		} catch (Exception e) {

			// TODO Auto-generated catch block

			response.getWriter().append("Exception occured : ").append(e.getMessage() +" :");

			

			e.printStackTrace(response.getWriter());

		}

		

		

	}

if the below snippet shows error, on the underlined part , you need to set the access restrictions to Warning as shown in the next picture.

The import section:

This code was tested by my colleague and for him the formatting did not render properly on Microsoft edge but worked on Firefox and Chrome.

Disclaimer : We are not having this for productive use and so should you.

Regards

Fariha

Remediation of uncalled active ICF services

2020-06-18T10:23:53+02:00

Web applications and web services to rule them all

Updates:
2022-11-07: Added hint for new secure-by-default logs.

The time of SAP GUI as a proprietary interface for every user interaction seems to be over soon. SAP is moving towards serving more and more applications as web applications or web services - be it SAP Fiori, be it the Webgui utilising Screen Personas or OData or REST APIs.

While this change counts in for sure to better user experience or using open standards for interfaces (e.g. towards cloud services), it also effects the SAP Basis Administrator:
A SAP basis administrator nowadays need to have a deep understanding of web technologies (additionally to understanding the SAP application server, the database as well as to the operating system like linux).

I will not go into detail about the journey from the integration of Internet Communication Manager (ICM) as web server into SAP NW AS ABAP/Java or what to consider in general when operating a web server within your ERP system - maybe even exposed to the internet.
In this blogpost I would like to catch up a topic which is more related to the content served by the Internet Communication Framework (ICF) through the ICM.

“Please activate one or the other ICF service - it is urgent!”

In the early days - before "Secure by Default" was a claim - SAP NetWeaver AS ABAP based systems were shipped with certain ICF services in status "activated". In addition to that, SAP Basis Administrators often where asked on short notice to quickly activate one or the other service in transaction SICF until some urgent needed functionality works. So it happened that there were more ICF service activated then ever needed, especially in the production system.

While in the meantime SAP released many security notes to fix vulnerabilities in the SAP standard ICF services, in many systems a number of 500 up to more than 3000 ICF services are still enabled although they are not needed nor called.

Bring some light into the darkness

Please note: As of SAP S/HANA-Version 2022 / ABAP Platform 2022 the so called secure-by-default logs for ICF calls are collected. These logs can be evaluated in transaction SBDLOG. Those can be used to activate all ICF services that have ever been logged or deactivate services that were not logged by choosing 'Menu' -> 'ICF Integration' in transaction SBDLOG. With this, the manual steps described below can be omitted.

At first lets export a list of the active ICF services of all of your systems (Dev, Int, Prod) by the following steps:

Go to transaction SE38.

Execute report RS_ICF_SERV_ADMIN_TASKS.

Choose “Export of Active Services to CSV File” and execute to save the file, e.g. as <SID>_active_services.csv

Again. Repeat these steps for every system in your landscape.

To give yourself an overview about the active ICF services in your systems take a look at the exported lists. By screening every list you will figure out that the active services in the various systems of a system landscape will be different from system to system.

Please be aware for some services there is a good reason to be active in development or integration system only! There are services used for development purposes or there might be services for features which are not yet released to production. Besides that, there are web applications used only for one time tasks or initial setup. Or active services differ simply due to configuration drift.

The main purpose of this lists is to use it a) as a template for the deactivation of uncalled ICF services in the next steps and b) as a backup to quickly mass re-activate all former active services in emergency case.

What about service usage?

It is strictly advisable to activate ICF services only if they are necessary for business needs in order to reduce the attack surface. Often there is no documentation which services are involved in what business functionality, some of them are even involved in more than one since they provide a framework functionality (e.g. for Webdynpro ABAP or BSP). So it might be hard for you to determine which service is truly needed in the first.

As a quick win you could analyse how often each service were called in each of your systems. To do so there are at least three methods:

extract the relevant info from the HTTP access log of the ICM (parameter icm/HTTP/logging_<xx>).

enable and evaluate the ICF trace using report RS_ICF_SERV_ADMIN_TASKS as mentioned in SAP note 2430473.

evaluate the Web Statistics.

Method 1 might be time consuming to gather all log files and grep and normalize the relevant parts.

Method 2 could have a performance impact as of SAP note 1611713.

Since Web Statistics are collected by default I recommend to use method 3. However, I like to advise to prolong the retention period of Web Statistics for this purpose in advance by following these steps:

Go to transaction ST03.

Go to Collector and Performance DB -> Performance Database -> Workload Collector Database -> Reorganization -> Control.

Adjust retention period for the WEB statistics, e.g. TOTAL Monthly Aggregates Retention Period for `VC` and `VD`.

Again: Repeat these steps for every system in your landscape.

After a reasonable time frame in which the Web Statistics for relevant phases (month end closing or alike) have been collected, the statistics can be exported by following these steps:

Go to transaction ST03.

Expand Workload -> Total -> Month -> and perform for each available month the following steps.

Expand Analysis Views -> Web Statistics -> WEB Server Statistics.

Switch to tab “URL”.Note: The Web Statistics may contain entries for services which are not even present in the system but are requested for example by a scanning server.
Hint: You may have noticed the column “Protocol” indicates if a service is called via HTTP or HTTPS.

Export the list of URLs as spreadsheet (“Excel (in Office 2007 XLSX Format)“) using the “Export” button. (Note: available as of SAP_BASIS 7.02).

Again: Repeat these steps for every system in your landscape.

Put the puzzle together

Now it is time to compare the list of active services with the list of called services to prepare the cleanup.

You can also think of comparing the lists across your system landscape. As already stated, for your development and integration system you should consider that there are indeed services active which are necessary for development purposes only or services which are in acceptance test and not yet set productive. These should be evaluated for the relevant systems. Talk to the developer team!

Besides that there may also be web applications activated which are used only for initial setup tasks, e.g. SAML2 configuration or troubleshooting e.g. sec_diag_tool. You should consider to activate these only at configuration time or as long as needed.

There may also be services which are actively used in the production system but are not activated in one or another system of the system landscape. It's time to eliminate this configuration drift.

Ok, lets start the preparation:

Copy the export of active services CSV file as a template.

Remove all lines which have an entry in column REF_PATH. These are aliases which point to a service node. Aliases can not be deactivated, but they will stop working if the original service is disabled.

Remove all lines for called services and their parent paths from the list so that you end up with a list of ICF services which can be deactivated in the relevant system.

Make sure no parent node stays in the list to be deactivated while it has sub nodes which should remain active. This would lead to so called "stale nodes" and non-working services. For example if /sap/bc/echo should stay active remove /sap, /sap/bc and /sap/bc/echo from the list.

Save this list of your to-be-deactivated services as CSV file.

Again: Repeat these steps for every system in your landscape.

Time to cleanup

Now you can start deactivating unused services in each system with your processed templates by following these steps:

Open the list of active ICF services, e.g. <SID>_acvite_services.csv and doublecheck if it holds only to-be-deactivated ICF services.

Go to transaction SE38.

Execute report RS_ICF_SERV_MASS_PROCESSING.

Select “Deactivate ICF Services for All Virtual Hosts Listed in CSV File” and execute.

Confirm the popup and upload the list to deactivate all services in the list.

Again: Repeat these steps for every system in your landscape.

Did you reveal a configuration drift? Activate the missing services in the relevant systems either manually in transaction SICF or by preparing a CSV file for mass activation.

Maybe you have overlooked some parent paths during creation of the list and they have now been deactivated accidentally. This is not that fatal. You simply can perform a fresh "Export of Active Services to CSV File" and use this to “Activate ICF Services for All Virtual Hosts Listed in CSV File”. The activation logic of the report will then take care of activating also all necessary parent nodes.

Keep in mind if something goes totally wrong you have also the initial export of active services as a backup which can be used to mass activate everything again as it was before.

Just as a side note:
The UCON HTTP whitelist scenario or former HTTP_WHITELIST does not serve for the same purpose as the UCON RFC Basic scenario. Meaning it does not affect the general reachability of certain paths through ICM! But this is a topic for another blogpost.

Whats next?

After finishing the deactivation in all systems, I recommend to "Export of Active Services to CSV File" once again. With this list you should start documenting your web services and their business need.

I started to collect information about SAP standard ICF services in https://github.com/J-Goerlich/Standard_ICF_services which may give you a hint if a service is needed in your scenario.

SMAINTENANCE - Automation Of Regular Maintenance Tasks

2022-01-10T13:18:59+01:00

Hi All,

Being a SAP Admin you need to frequently deal with various maintenance activities involving application database or operating system. SAP has come up with tcode - SMAINTENANCE to make SAP application ramp down/up activity easy for us.

SMAINTENANCE tcode can be used to monitor and control the status of the system in terms of the so called "Maintenance Mode".

Prerequisite

For using smaintenance t-code we need to create security policy from t-code SECPOL. Below two attributes are mandatory to use smaintenance t-code

TENANT_RUNLEVEL_LOGON_PRIVILEGE = 1

SERVER_LOGON_PRIVILEGE = 1

This security policy needs to be assigned to all system Admin users in SU01 which needs to be allowed when system is in maintenance mode

Below is the screen of t-code smaintenance

When we "Switch to Maintenance" only Admin users who are having security policy assigned are allowed to login to system and perform maintenance activity.

Remaining all users including system users are blocked against SAP logon.

Switch to Maintenance

The action "Switch to Maintenance" starts a workflow which sets the system to mode "In Maintenance". The workflow consists of the modes as described above: "Running -> Web dispatcher closed -> Cool down -> In Maintenance". The current duration of the whole workflow is 10 minutes.

Switch to Running

The action "Switch to Running" starts a workflow which sets the system to mode "Running". The workflow consists of the modes "In Maintenance -> Running". The switch to "Running" is performed immediately.

On the top current system status is displayed as show in below

There are different modes system goes through:

Running (Runlevel - 0)
The system is fully operational for business end users and administrator. There are no restrictions for services (e.g. batch, rfc, ...) or for inbound and outbound connections.

Web dispatcher Closed (Runlevel - 4)
The system is fully operational for business end users and administrators but connections to the Web dispatcher from outside are blocked. That is users connected via the web dispatcher cannot work any longer.

Cool down (Runlevel - 9)
The system is fully operational for administrators only. Business users are expected to finish their work and logout. At the end of the cool down phase business end users' sessions are terminated.

In Maintenance (Runlevel - 100)
The system is fully operational for administrators only. Administrators are users which have a special security policy assigned. There are no business end users logged onto the system.

Error during mode switch
An error occurred during a system mode switch.

Below you see the so called "Maintenance Periods" and a "Log" of the maintenance mode.

Maintenance Periods
The maintenance periods are time periods in which the system is set to Maintenance Mode or where the system is shut down. Maintenance Periods may be defined by external monitoring tools or from within the system by creating a new entry in this view. Only entries created from within the system may be deleted here.

There is no automatic mode switch implemented according to this schedule. By default the schedule of the current year is displayed. Use the selection button to modify this default selection.

Log
The log shows messages created by the framework which performs system mode switches. By default the log of the current month is displayed. Use the selection button to modify this default selection.

When system is in maintenance mode below things are restricted

Users which are not having security policy assigned are prevented to logon

Background jobs are not allowed to run during maintenance mode

All sessions and users are logged off post 10 mins upon activating maintenance mode

HTTP sessions(webservices) are also closed and users will get 503 error

External interfaces/RFC are restricted to connect SAP system

Message end users will see when system in maintenance mode

By using this we need not worry about ramp down activities such as users locking/unlocking, Job suspend, system messages, etc during any maintenance related task

References link : https://blogs.sap.com/2020/06/18/abap-platform-part-3-whats-new-for-the-basis-administrators/

https://help.sap.com/viewer/e067931e0b0a4b2089f4db327879cd55/202110.000/en-US/79b58c0b017f437aad8f4128980a06a7.html?q=Maintenance%20mode

Fiori-like web app development in pure ABAP with htmx and Fundamental

2022-02-10T22:21:30+01:00

Introduction

Are you a die-hard SE80 ABAP developer, or allergic to JavaScript? Or perhaps you just want to create some "freestyle" custom Fiori-like apps for your clients or your company without wasting too much time learning new frameworks or relying on some third party?

If so, then this post might be of some interest to you.

Don't get me wrong, I do like JavaScript as a programming language, but I would like to present an alternative to the Single Page Application (SPA) frameworks, like Angular, Vue, React and SAPUI5 that have taken the world by storm over the last decade.

In this blog post, we take a look at the main differences between the SPA model and the model promoted by htmx, and explore a small app to demonstrate its usage.

From SPA to htmx

Single page application (JSON over the wire)

As a reminder, Single Page Applications are applications built to run on a single webpage. After the initial load of one HTML page and some JavaScript, they rely upon Ajax ("Asynchronous Javascript and XML") requests to pass JSON data objects to and from the server to the client to update the HTML page via JavaScript and the Document object model (DOM) API, without the need to reload the entire page.

Single Page Application lifecycle

HTML (fragment) over the wire

In December 2020, David Heinemeier Hansson, creator of Ruby on Rails, CTO and co-founder of Basecamp, got some attention (at least mine) with a blog post proposing a departure from the SPA model.

You can write fast, modern, responsive web applications by generating your HTML on the server, and delivering that (with a little help) directly to the browser. You don’t need JSON as an in-between format. You don’t need client-side MVC frameworks. You don’t need complicated bundling and transpiling pipelines. But you do need to think different. [...]

When we embrace HTML as the format to send across the wire, we liberate ourselves from having to write all the code that creates that HTML in JavaScript. You now get to write it in Ruby or Erlang or Clojure or Smalltalk or any programming language that might set your heart aflutter. We return the web to a place full of diversity in the implementations, and HTML as the lingua franca of describing those applications directly to the browser.

https://m.signalvnoise.com/html-over-the-wire/

This sounds like old SSR (server-side rendering) from the pre-SPA era, but with a twist: after receiving HTML from the server, the browser asynchronously requests fragments of HTML, instead of JSON data, to dynamically alter parts of the page based on user interactions or events occurring on the server. The logic, and the state, remain on the server.

HTML over the wire lifecycle

I later learned that the model behind this "HTML over the wire" concept was not so new and already expressed in other frameworks such as Phoenix LiveView (2018) or Laravel Livewire (2019).

Htmx library

But there’s an even longer-term advocate of this model: Carson Gross, creator of the htmx library.

While htmx is fairly new with its first release in 2020, its predecessor, intercooler.js, dates back to 2013.

Carson is a natural contrarian, as his pinned Twitter post shows, and his company motto too ("We find hot, new industry trends and then do the opposite of that").

To quote the website, htmx allows you to access AJAX, CSS Transitions, WebSockets and Server-Sent Events directly in HTML, using attributes, so you can build modern user interfaces with the simplicity and power of hypertext.

Htmx is small (~10k min.gz'd), dependency-free, extendable & IE11 compatible.

It's also an attempt to complete HTML as a hypertext (as its name implies, htmx is an extension to HTML).

Basic examples

The htmx library is provided as a simple JavaScript file you can just reference from a CDN: no bundling is required.

In this example, when you click on the button, htmx issues a POST request to the url "/clicked" (because of the "hx-post" tag) and swaps the button tag with the (html fragment) responses (because of the "hx-swap" tag), without reloading the full page.

And you can also issue a GET request or swap the innerHTML or any other tag of the current html page if you want.

More examples are provided on the website and I highly recommend that you have a look at them here.

What makes htmx special is its minimalism:

You don't need any tooling.

You can adopt htmx incrementally.

You can do a lot purely in terms of HTML (without any JavaScript).

If you really want/need some interactivity for your pages without touching the server, you can always use lightweight client frameworks such as:
- Alpine.js,
- petite-vue,
- hyperscript (Carson's own library) - look at this article for a short introduction,
- or VanillaJS.

If you want more information about the concepts behind htmx (REST, HATEOAS), I encourage you to watch this talk from Carson (just mentally replace Django by SAP and Python by ABAP, and all his talk remains relevant, thanks to the "HOWL stack" — Hypertext On Whatever Language).

Fundamental Library Styles

If you want to give your app a Fiori look, don't look any further than the Fundamental Library Styles, a light-weight presentation layer that you can use with any SPA framework and even with plain HTML; a perfect match for htmx.

Another well-suited option for htmx might be Web Components, but I haven't experimented with them yet.

Small demo app

Introduction

To give you a better feel of the potential of a "Hypermedia-Driven Application" on SAP, I created a micro "single class application" in just 195 single lines of ABAP code.

It will illustrate 3 UX patterns made possible by htmx (among many others):

active search: search as the user enters text,

out-of-band (oob) content update: update multiple HTML fragments with the same http response,

and infinite scroll.

Installation

You can choose any IDE to develop such apps, even your tried and tested SE80.

The code of this app/class is available on Github here.

It should work out of the box on any 7.51+ system. This requirement is not related to htmx, but to my use of some ABAP keywords. Actually, htmx should work with any system starting from the 6.10 release of Web Application Server.

Just copy the raw data and paste it to a new ZTF_HANDLER class (after selecting "Source Code-Based" if you are using SE80).

Once the code is activated, head over to SICF to create a new service.

It can be on the root or, like in the example below, under a 'custom' parent service with no handler.

Add your class name to the handler list and save.

And finally, in the SICF tree, right-click on your service and select "Activate Service", then "Test Service".

Your browser should open automatically and display your service for testing.

Note that the search function of the app is really basic, and case sensitive.

Also pay attention to the scrollbar handle on the right when you scroll down the results: it goes up every time a batch of 100 new rows is appended to the table.

Some code explanations

Before diving into the code, we have to keep in mind the structure of the app and its components.

Please also note that this app is bare-bones on purpose: to keep the code clear and simple, and focus on htmx.

The ABAP code is straightforward, so I will only explain the parts involving the htmx library.

if_http_extension~handle_request

Like every ICF service handler, the ZTF_HANDLER class implements the if_http_extension interface and its if_http_extension~handle_request method.

This method acts as the "controller" part of the app.

First we filter the HTTP method to only keep the GET requests, and then we get the current path of the app and the searched string, if any.

Then we check if the HTTP request is issued by the browser following normal navigation or from the htmx library (the 'HX-Request' header field is always populated with the value "true" for every htmx-initiated XMLHttpRequest).

In the first case (initial load of the application), all the fragments making up the whole page are returned to the browser.

In the second case, only the fragments required by the "app-action" are returned.

Each HTML fragment is generated by its own method (prefixed with 'html_').

Note that the "app-action" is a custom header field and not provided by the htmx library; its name is arbitrary and we will see later where this header field is defined.

Each "app-action" (think of it as an "OK code") triggers a different response from the server.

search
- The whole table is sent to the browser, with the first batch of rows (100 rows or less).

search_init
- Same as "search" but the searched_string is cleared and another HTML fragment is sent "out of band" with the response, the search bar itself, to clear its content. This "oob" feature allows you to update not only one, but as many HTML fragments of the original page within the same response as you want.

scroll
- When the user scrolls the list, a request is automatically sent to the server to get the next batch of rows (we will see how later).

html_page

This app only has three dependencies:

the htmx.js file for the core htmx library,

the fundamental-style.css file for the Fundamental Library Styles,

the fonts used by the Fundamental Library Styles (see here for more info).

Here we link to a CDN but you should probably store these libraries in the standard SAP MIME Repository or using the ICM or on any other internal HTTP server.

We also added a "htmx-config" meta tag to configure the default htmx swap mode with "outerHTML", to swap the whole fragment and not only its content (as with the default "innerHTML" mode).

html_searchbar

To get started, all htmx attributes begin with "hx-" or "data-hx-". The two forms are equivalent but the latter doesn't issue errors when you check your generated HTML code with some tools like this one.

Here we have two reactive elements:

an input element for the search string,

a button to refresh the search bar and the list.

Here are some basic explanations about the various htmx attributes used here.

data-hx-push-url
- Note that this attribute, like the data-hx-target attribute, is inherited by the child tags; so, instead of repeating this attribute on the input and button tags, we can just place it on the parent div tag.
- This tag is used to push the URL into the location bar; each time we search a new table name, it creates a new entry history, so that we can navigate back to our previous searches.

data-hx-target
- This attribute allows us to target a different HTML element for swapping than the one issuing the request.
- The target can be any valid CSS query selector (and more).

data-hx-trigger
- This attribute allows us to specify what triggers the request.
- As we want an "active search", the request will be triggered 250ms after the user stops typing (or if he leaves the search field).

data-hx-get
- This attribute causes an element to issue a GET request to the specified URL.

data-hx-headers
- This attribute allows us to add to the headers that will be submitted with the request. Its value is in JSON format.
- "app-action" is the arbitrary header field name I chose to send to the if_http_extension~handle_request.

data-hx-swap-oob (in the first <div>)
- This attribute allows you to specify that some content in a response should be swapped into the DOM somewhere other than the target, that is "Out of Band". Thanks to this attribute, when the user initialises their search, the server response updates both the html table and the search bar. Of course, this attribute is not inherited.

You can find more information about these attributes and the other htmx attributes here.

html_table_rows

Here, we not only display the batch of table rows but also an invisible row whose purpose is to trigger the load of the next batch of rows when it is scrolled into the viewport (or "revealed" as defined in the "data-hx-trigger" attribute).

The "data-hx-vals" attribute allows us to add some parameters to those that will be submitted with the request. We have to use this attribute to get the next batch of rows with the same search string as the original request.

The "data-hx-target" and the "data-hx-swap" attributes are defined so as to add the new batch of rows to the end of the table.

Advice from my own experience

Use htmx

You can find some libraries comparable to htmx (I first tried unpoly) but the minimalism of htmx pays off in the end.

Embrace HTML and CSS

When I first experimented with htmx, my initial idea was to create an ABAP library to encapsulate HTML, htmx and the Fundamental Library Styles, but it was tedious and without any real added value.

HTML and CSS are two of the core technologies for building webpages: you will not waste your time adding those skills to your toolbox.

You can head over to the Fundamental Library Styles website to get started. Just select a component and click on "Show code" to get the required HTML and CSS.

Learn how the SAP Internet Communication Framework works

You can design your own app architecture in many different ways and with many different ABAP technologies (BSP, ABAP REST Library...) but using the ICF fully and writing your own HTTP handlers is a really good option.

You can have multiple HTTP handler classes handling the same request and split your app in a tree of ICF services where each service corresponds to a component, or a group of components, which completes the main server response, quite similarly to "nested routes" in frameworks such as Remix or in React Router v6.

Also, don't forget ICF logging.

Simplify your state management

If you are on HANA, store everything (including all user inputs) in the database; if you have to call BAPIs, store intermediate data in custom tables (just like SAPUI5 Draft Handling). You can even store each field update from the user.

Stay humble

When you think there is an issue with the htmx library, check your code instead (and the htmx documentation or discord).

Conclusion

After a few weeks of using htmx, here are the main advantages and disadvantages of this library, from my point of view.

Pros

Full ABAP with direct access to existing BAPI, FM, classes, CDS views...

Easy to grasp and well-documented libraries (both htmx and Fundamental Library Styles)

Fast iterative process
- No build process, you just have to activate your ABAP code.
- When building and testing HTML fragments, you don't even have to reload your HTML page.

No mockup data
- You have your full DB data available at your fingertips.

Simplified state management

No API / Frontend desynchronization

No duplication of logic

Code editor of choice
- I personally use VSCodium on Linux without a glitch, thanks to murbani and lars.hvam,
- but ADT and SE80 are fine.

Easier debugging
- All your code is in one place and you have no dependency on external code.

Architecture freedom
- on the server-side
- on the frontend: I used Fundamental Library Styles but you can use any CSS framework if you want.

Performance
- It could be counter-intuitive because of all these round trips between the browser and the SAP server, but the fact is htmx is damn fast (faster than Fiori apps in our S/4HANA environment).

Security
- The htmx library itself is less than 2,500 lines of easily auditable JavaScript code and, with it, you avoid using any other JavaScript (npm) module, usually overwhelmingly found in current SPA frontend developments or toolings.

Ubiquity
- You can integrate htmx with any server-side framework using any language such as Python, C#, Java, Ruby, Julia, Lisp, Clojure, Go, Haskell or even JavaScript!

Cons

Deviation from the web development model promoted by SAP

Not the best solution for fast prototyping
- But as a programmer once said: "In the beginning you always want results. In the end all you want is control".

No ecosystem of reusable components (yet!)

I would really enjoy seeing some of you try this htmx library so that we can share our experiments and best practices (and soon, "hmtx" might even become a new SAP community tag!).

(This blog post is a tribute to brian.mckellar and thomas.jung whose book "Advanced BSP Programming" had been gathering dust on one of my shelves for too many years).

Exploring web app development with ABAP & htmx (in comparison with ABAP RAP)

2022-04-08T10:01:32+02:00

1. Introduction

This is a personal sequel to Fiori-like web app development in pure ABAP with htmx and Fundamental by patrick.villeneuve to explore further the possibilities of combining htmx and ABAP to develop business web apps.

1.1 Motivation

The world is shifting towards SAP web development using SAPUI5 and ABAP RAP model on a platform like BTP, and it feels like all the years and efforts spent on developing pure ABAP applications and accumulating the know-how are starting to be forgotten.

Then Patrick's blog caught my eyes. The blog introduces a web app development using htmx to control the frontend and ABAP on the backend. To put this in the modern SAPUI5 MVC architecture, "view" is managed by htmx, "controller" is managed by ABAP, and "Model" is not needed because ABAP can directly access the database.

In this blog, I will go through my demo app to explain the interaction between htmx and ABAP, as well as how the CRUD operations can be handled. I aimed to create a business application which could be used by the real world business user, in order to share the feasibility and effort needed for this new development approach.

1.2 htmx in a Nutshell

The most concrete explanation and philosophy behind htmx can be found in the original blog. It's got nice illustrations too. But in a Nutshell, what makes it special are:

Any HTML element can issue an HTTP request to the backend

Not only clicking can trigger HTTP request but also scrolling, as user enters value, and even with shortcut key

Any element on the page can be updated(swapped) without updating the entire page

A lot can be achieved on the frontend solely using htmx, without using JavaScript

If you are new to htmx(like me) and can't wrap your head around these concepts, that's ok! Nothing helps you understand better than getting your hands dirty!

2. Demo app

Let's dive right into the demo app. This Sales Order Update App allows user to search the Sales order by certain selection filter and update line item information. The update result will be displayed on the Status column.

2.1 Implementation steps

Go to SE24 or SE80 and implement the backend ABAP class/methods. Here is the code of this app.

Create a new custom service in SICF and activate it. Detailed steps can be found in the original blog. In this demo, I named my class "ZHTMX_HANDLER_SO" so that class should be set in your service. Right click the service and "Test Service" will open the app on your default browser.

2.2 Code explanation

2.2.1 Initial call

When the Service URL is accessed, the class will be called and method "IF_HTTP_EXTENSION~HANDLE_REQUEST" is triggered. Here, first we get the query string and form data send on the request from the browser. In the initial call there is no string query or form so will come back to that. Then Depending on the method type, the code goes to different logic. The initial call will be GET and "hx-request" will always be empty. hx-request will be true if the request is triggered by htmx element such as "hx-get" and hx-put". So the code will call 4 different methods(HTML_PAGE, HTML_SHELLBAR, HTML_SELECTION, HTML_TABLE) in order to create the first view of the page. Each methods appends the html fragments into variable "HTML", which is also their return value. SERVER->RESPONSE->APPEND_CDATA will return the whole HTML code back to browser as the Response.

METHOD IF_HTTP_EXTENSION~HANDLE_REQUEST.



    "Get Request parameters

    ME->GV_PATH = SERVER->REQUEST->GET_HEADER_FIELD(

                 IF_HTTP_HEADER_FIELDS_SAP=>PATH_TRANSLATED_EXPANDED ).



    "Get the query value Order type

    ME->GV_AUART = ESCAPE( VAL = SERVER->REQUEST->GET_FORM_FIELD( `a` )

                                  FORMAT = CL_ABAP_FORMAT=>E_HTML_TEXT ).

    "Get the query value Sales Org

    ME->GV_VKORG = ESCAPE( VAL = SERVER->REQUEST->GET_FORM_FIELD( `v` )

                                  FORMAT = CL_ABAP_FORMAT=>E_HTML_TEXT ).



    "Get the SO number user is operating

    ME->GV_SO_KEY = ESCAPE( VAL = SERVER->REQUEST->GET_FORM_FIELD( `k` )

                                  FORMAT = CL_ABAP_FORMAT=>E_HTML_TEXT ).



    "Get form data

    CALL METHOD SERVER->REQUEST->GET_FORM_FIELDS( CHANGING FIELDS = GT_FORM ).





    "Get method

    IF SERVER->REQUEST->GET_HEADER_FIELD(

         IF_HTTP_HEADER_FIELDS_SAP=>REQUEST_METHOD ) = `GET`.



      IF SERVER->REQUEST->GET_HEADER_FIELD( `hx-request` ) IS INITIAL.



        SERVER->RESPONSE->APPEND_CDATA( HTML_PAGE( ) ).

        SERVER->RESPONSE->APPEND_CDATA( HTML_SHELLBAR( ) ).

        SERVER->RESPONSE->APPEND_CDATA( HTML_SELECTION( ) ).

        SERVER->RESPONSE->APPEND_CDATA( HTML_TABLE( EXPORTING FORM = GT_FORM ) ).



      ELSE.



        CASE SERVER->REQUEST->GET_HEADER_FIELD( `app-action` ).



          WHEN `search_init`.

            "Implement Search Init logic of your choice



          WHEN `scroll`.



            GV_PAGE = SERVER->REQUEST->GET_HEADER_FIELD( `app-page` ).

            SERVER->RESPONSE->APPEND_CDATA( HTML_TABLE_ROWS( EXPORTING FORM = GT_FORM ) ).



          WHEN `edit`.

            SERVER->RESPONSE->APPEND_CDATA( HTML_EDIT_ROWS( EXPORTING FORM = GT_FORM ) ).



          WHEN `cancel`.

            SERVER->RESPONSE->APPEND_CDATA( HTML_CANCEL_EDIT( EXPORTING FORM = GT_FORM ) ).



        ENDCASE.



        DATA(LV_ACTION) = SERVER->REQUEST->GET_HEADER_FIELD( `app-action` ).



      ENDIF.



      SERVER->RESPONSE->SET_STATUS( CODE = 200

                                    REASON = IF_HTTP_STATUS=>REASON_200 ).

      SERVER->RESPONSE->SET_CONTENT_TYPE( `text/html` ).



    ENDIF.



    "Put Method

    IF SERVER->REQUEST->GET_HEADER_FIELD(

               IF_HTTP_HEADER_FIELDS_SAP=>REQUEST_METHOD ) = `PUT`.

      CASE SERVER->REQUEST->GET_HEADER_FIELD( `app-action` ).



        WHEN `search`.

          SERVER->RESPONSE->APPEND_CDATA( HTML_TABLE( EXPORTING FORM = GT_FORM ) ).



        WHEN `save`.

          SERVER->RESPONSE->APPEND_CDATA( HTML_SAVE_EDIT( EXPORTING FORM = GT_FORM

                                                          IMPORTING STATUS_MSG = GV_STATUS_MSG ) ).

      ENDCASE.



      SERVER->RESPONSE->SET_STATUS( CODE = 200

                                    REASON = IF_HTTP_STATUS=>REASON_200 ).

      SERVER->RESPONSE->SET_CONTENT_TYPE( `text/html` ).

    ENDIF.





  ENDMETHOD.

2.2.2 Fundamental library and htmx library

In HTML_PAGE, the header of the app page is defined. The important point here is that Fundamental Library and htmx library are defined. In the later section of the code, you will find html class such as "fd-table" and "fd-input" and attributes such as "hx-headers" and "hx-target". "fd-" are referring to Fundamental library to give SAP Fiori theme UI and "hx-" attributes enables htmx function from htmx library.

`<link href='https://unpkg.com/fundamental-styles@0.22.0/dist/fundamental-styles.css' rel='stylesheet'>`

`<script src="https://unpkg.com/htmx.org@latest/dist/htmx.js"></script>`

2.2.3 Frontend/Backend interaction by htmx

By pressing the search button, PUT request is triggered with the service URL of this app. This behavior is defined in HTML_SELECTION. "data-hx-put=" defines the service to be triggered when the search button is pressed. In this case, GV_PATH contains the URL path initially triggered, and that will be triggered again when the button is pressed. Whatever set in "hx-headers=" will be added to Request header when the service is triggered. In this case, "app-action = search" will be added on the header and when the service is triggered by "data-hx-put", the code will process into the case statement where "WHEN `search` = true" in the main HANDLE_REQUEST method. In other words, whatever set in "hx-headers" works like a OK code in ABAP dynpro and it gets picked up in the main HANDLE_REQUEST method.

Another point to mention here is that this button is inside a "form", which means that the input values(Document type and Sales Org) will be passed as form data on the Request when the search button is pressed. Form data is fetched by method GET_FORM_FIELDS in the main HANDLE_REQUEST and later used to filter the SELECT statement. The purpose of those input fields are to filter the output of sales orders.

  METHOD HTML_SELECTION.



    CONCATENATE

     `<form class="fd-form__item">`

       `<label class="fd-form__label" for="auart"> Document type </label>`

       `<input id="auart" class="fd-input fd-input-group__input" style="max-width: 100px;" type="text" name="Document type" >`

       `<label class="fd-form__label" for="vkorg"> Sales Org </label>`

       `<input id="vkorg" class="fd-input fd-input-group__input" style="max-width: 100px;" type="text" name="Sales Org" >`

         `<button type="button" class="fd-button" `

                  `aria-label="clear search" `

                  `data-hx-get="` GV_PATH `" `

                  `data-hx-headers='{"app-action": "search_init"}'>`

            `<i class="sap-icon--clear-all"></i>`

          `</button>`

         `<button type="button" class="fd-button" `

                  `aria-label="saerch" `

                  `data-hx-target="#sap_tables" `

                  `data-hx-swap-oob="true" `

                  `data-hx-put="` GV_PATH `" `

                  `data-hx-headers='{"app-action": "search"}'>`

            `<i class="sap-icon--search"></i>`

          `</button>`

     `</form>`

    INTO HTML.





  ENDMETHOD.

Similarly, Edit button on each table rows are also calling back the class method every time they are pressed. Here, form is not used but "hx-vals" allows you to add search string to the request and in this case, search string k with value of GV_SO_KEY is passed. GV_SO_KEY contains the sales order + item number key which is concatenated before TAB_ROW_DISP_MODE is called. This is for the callback program to identify which sales order row the user is trying to change.

  METHOD TAB_ROW_DISP_MODE.



    "Put the row to display mode

    CONCATENATE HTML

    `<tr class="fd-table__row fd-table__row--hoverable">`

      `<td class="fd-table__cell">` DATA-VBELN `</td>`

      `<td class="fd-table__cell">` DATA-AUART `</td>`

      `<td class="fd-table__cell">` DATA-VKORG `</td>`

      `<td class="fd-table__cell">` DATA-POSNR `</td>`

      `<td class="fd-table__cell">` DATA-MATNR `</td>`

      `<td class="fd-table__cell">` DATA-KWMENG `</td>`

      `<td class="fd-table__cell">` DATA-VRKME `</td>`

      `<td>`

        `<button class="btn btn-danger"`

                `data-hx-vals='{"k": "` GV_SO_KEY `"}' `

                `data-hx-get="` GV_PATH `" `

                `data-hx-headers='{"app-action": "edit"}' >`

          `Edit`

        `</button>`

      `</td>`

      `<td class="fd-table__cell fd-info-label--accent-color-6" style="margin:0.2rem"">` STATUS_MSG `</td>`

    `</tr>` INTO HTML.





  ENDMETHOD.

Other htmx initiated user interactions include, pressing cancel buttons, pressing save button and scrolling down to fetch more records. They all call back the backend ABAP class method and return with the response data.

2.2.4 Swapping in htmx

One of the attractive feature of htmx is that you can swap and replace certain part of the page without returning the whole page of HTML. This is achieved by first defining the default swapping mode. "outerHTML" replaces the entire HTML element that is in process. Here you can find other swapping modes.

<meta name="htmx-config" content='{"defaultSwapStyle":"outerHTML"}'>

Let's look at an example when user presses Edit on one of the rows. WHEN `edit` will be true and HTML_EDIT_ROWS is called, in which calls TAB_ROW_EDIT_MODE. This method is only returning one row of table in HTML, NOT the whole page of the app starting from the Shell bar to the bottom of the table.

OuterHTML swapping is used almost everywhere in this app, but the search button is using different kind of swapping. hx-swap-oob comes in handy when you want to swap other part of the page instead of itself. When search button is pressed, no change on the button itself is required but the table contents below should be refreshed. So that's why hx-target="#sap_tables" is set, which means this button is intended to swap the contents of "sap_tables", which is the id for the HTML table.

         `<button type="button" class="fd-button" `

                  `aria-label="saerch" `

                  `data-hx-target="#sap_tables" `

                  `data-hx-swap-oob="true" `

                  `data-hx-put="` GV_PATH `" `

                  `data-hx-headers='{"app-action": "search"}'>`

            `<i class="sap-icon--search"></i>`

          `</button>`

2.3 CRUD operation

This app uses Read and Update of the sales document data so I will only highlight how Create and Delete can by handled.

Create: Define a "Add" button with attribute "hx-headers='{"app-action": "add"}'" and set app's callback URL on "hx-get". In the main HANDLE_REQUEST method, create a CASE statement for "add" and call BAPI or BDC of your choice to create sales order.

Delete: Define a "Delete" button on each row of the table with attribute "hx-headers='{"app-action": "delete"}'" and set app's callback URL on "hx-get". The rest is same as Create. Create your own logic to delete the sales order item. One thing you have to remember is that nothing should be returned by APPEND_CDATA on the request's response to make sure that the deleted item will be removed from the HTML table.

So it's very straightforward! Just need to use htmx initiated request & htmx swapping wisely and combine it with backend ABAP to update the SAP database.

2.4 Exercise(Try it!)

Now I assume you have pretty good idea how swapping and htmx initiated request work. If you'd like, you can implement your own logic for the "search clear button", as I left it empty on purpose😀.

          WHEN `search_init`.

            "Implement Search Init logic of your choice

3. Compatibility with ABAP

Through building this app, here is my summary of this development approach.

Full access to objects in SAP application/DB server through ABAP👍

No need to call API to fetch dataset thus no need to create/manage Odata in backend👍

Entire code is wrapped in one ABAP class for good maintainability (but you can always setup multiple services and classes in SICF)👍

The frontend code will be very light. All the complex logic is managed in backend ABAP👍

Input fields cannot directly refer to SAP data domain thus no automatic external/internal value conversion(had to manually convert doc number, sales org, etc.) 😕

A lot of effort to create select-options and F4 value help. They're so easy in ABAP though...😕

Need better idea to maintain HTML code than using string concatenation😕 -> In the next release, it would be cool if SAP integrated HTML editor in SE80, like this one!

There are pros and cons but since it's a new approach, there is always room for improvement!

4. Comparing the efforts with ABAP RAP Model

This new development model offers new possibilities for SAP web development and all, but does it save more time and hassle compared to the existing web app development framework? I used ABAP RAP to create nearly the identical app and turned out it took much less effort to build it😅.

On top of that, ABAP RAP model does not have the weakness of htmx & ABAP model, which are:

Internal/external format conversion is performed automatically

F4 search help comes as default

Select options/multiple selection are possible

on top of these advantages,

DB data is at your fingertip. BAPI call also possible to update database(not in the CRUD methods but only in the saver methods)

Coding is only needed on behavior class, which was less than 200 lines

The only drawback I felt there was is that I couldn't call BAPI anywhere I wanted in the behavior class method. BAPI parameters must be prepared in the CRUD methods and pass them as ABAP memory to the saver methods.

If you are not familiar with ABAP RAP model, please check this blog and I definitely recommend you to try it!

5. Conclusion

So I must admit that for this specific demo app requirement, ABAP RAP model is a better option. However, htmx is still super powerful and htmx & ABAP model brings so much possibilities to SAP web app development. If the weakness I mentioned can be overcome somehow, it will offer much more flexibility in the UI design, easier frontend backend synchronization, and much simpler development model.

The next step? I really hope that SAP will add new components to ABAP library to exploit the capability of htmx!

References

Fiori-like web app development in pure ABAP with htmx and Fundamental

Demo app source code

htmx library

Fundamental Library

ABAP on SAP Cloud platform – ABAP RESTful Programming Model (RAP) for beginners with CRUD example

SAP Community - NW ABAP Internet Communication Framework

The meaning of LIFETIME_RC

Identify the owner of the process holding the mutex lock

Purpose

Breaking down the MtxLock

The Mutex related trace entries

Identifying the caller id aka client id aka CID

Troubleshooting the entries

SICF on PI/PO single stack : Shortening Long URLs for customers inbound.

SICF alternative on PI/PO single stack.

Procedure:

Invalidating Cache is not working.Entries in ICM trace as "IctICmRemoveFile() failed. 1"

Purpose

Troubleshooting

Developing GraphQL API on ABAP: The Inspiration

GraphQL

Request and Response to GraphQL Server (image from https://www.howtographql.com)

SAP

Developing GraphQL API on ABAP: Architecture and Technical Details

Architecture

Architecture Diagram

Accessing the API

MYSAPSSO2 token for authentication

API Documentation

Queries — using BP Advanced Search

BP Advanced Search Results

Mutations — Creating BP with Deep Data

Mutations — Creating Child data of BP

Mutations — Updates and Deletes

At a Glance

Packages

Message Class — ZGRAPHQL

Important Classes

Logging incoming requests when creating short URLs

Now get target server root certificate in the comfort of your own browser without getting your local IP white-listed

Remediation of uncalled active ICF services

Web applications and web services to rule them all

Updates: 2022-11-07: Added hint for new secure-by-default logs.

“Please activate one or the other ICF service - it is urgent!”

Bring some light into the darkness

What about service usage?

Put the puzzle together

Time to cleanup

Whats next?

SMAINTENANCE - Automation Of Regular Maintenance Tasks

Below you see the so called "Maintenance Periods" and a "Log" of the maintenance mode.

Fiori-like web app development in pure ABAP with htmx and Fundamental

Introduction

From SPA to htmx

Single page application (JSON over the wire)

HTML (fragment) over the wire

Htmx library

Basic examples

Fundamental Library Styles

Small demo app

Introduction

Installation

Some code explanations

if_http_extension~handle_request

html_page

html_searchbar

html_table_rows

Advice from my own experience

Use htmx

Embrace HTML and CSS

Learn how the SAP Internet Communication Framework works

Simplify your state management

Stay humble

Conclusion

Pros

Cons

Exploring web app development with ABAP & htmx (in comparison with ABAP RAP)

1. Introduction

2. Demo app

3. Compatibility with ABAP

4. Comparing the efforts with ABAP RAP Model

5. Conclusion

Updates:
2022-11-07: Added hint for new secure-by-default logs.