# US 11,442,758 B2 · Integration flow execution renew

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 11,442,758 B2
- Document ID: US11442758B2
- Status: Granted
- Kind: B2
- Application number: 17/140,603
- Filed: 2021-01-04
- Published: 2022-07-07
- Granted: 2022-09-13
- Earliest claimed: 2021-01-04
- Assignees: Sap SE
- Applicants: Sap SE
- Inventors: Deepak MP
- Web page: https://patentgrep.com/patent/US11442758B2

## CPC

- G06F 9/45516: {Runtime code conversion or optimisation}
- G06F 16/252: {between a Database Management System and a front-end application}
- G06F 8/40: Transformation of program code
- G06F 9/54: Interprogram communication
- G06F 16/25: Integrating or interfacing systems involving database management systems
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

A method and system including receiving a set of integration steps to transfer data between a first application and a second application, wherein the set of integration steps includes execution of at least one component; transmitting the received set of integration steps to a blueprint generator; converting, at the blueprint generator, the received set of integration steps to a binary runtime executable code; inserting at least two input/output interceptors into the binary runtime executable code; receiving the binary runtime executable code at a runtime component; executing the received binary runtime executable code at the runtime component using data, in a case that execution of the at least one component is complete, an output of the executed at least one component is saved; in a case that execution of the at least one component is incomplete: receiving an update to the data; re-generating, at the blueprint generator, the binary runtime executable code for one or more an unexecuted integration steps; and executing the re-generated binary runtime executable code. Numerous other aspects are provided.

## Claims

### Claim 1

A computer-implemented method comprising:
receiving a set of integration steps to transfer data between a first application and a second application, wherein the set of integration steps includes execution of at least one component;
transmitting the received set of integration steps to a blueprint generator;
converting, at the blueprint generator, the received set of integration steps to a binary runtime executable code;
inserting at least two input/output interceptors into the binary runtime executable code;
receiving the binary runtime executable code at a runtime component;
executing the received binary runtime executable code at the runtime component using data,
in a case that execution of the at least one component is complete, an output of the executed at least one component is saved;
in a case that execution of the at least one component is incomplete:
receiving an update to the data;
re-generating, at the blueprint generator, the binary runtime executable code for one or more an unexecuted integration steps; and
executing the re-generated binary runtime executable code.

### Claim 2 (depends on 1)

The computer-implemented method of claim 1, wherein re-generating the binary runtime executable code is executed from a point when the at least one incomplete component receives the input update.

### Claim 3 (depends on 1)

The computer-implemented method of claim 1, wherein the set of integration steps are received as user interface data at an integration flow editor.

### Claim 4 (depends on 1)

The computer-implemented method of claim 1, further comprising in the case that execution of the at least one component is incomplete:
receiving, from the runtime component, a notification of the incomplete execution at an orchestration engine; and
identifying a component where the execution was incomplete.

### Claim 5 (depends on 4)

The computer-implemented method of claim 4, wherein identifying the component where the execution was incomplete further comprises:
retrieving a most recently saved input and a most recently saved output; and
determining a given component had an incomplete execution in a case that the given component has an input and no output.

### Claim 6 (depends on 4)

The computer-implemented method of claim 4, further comprising:
extracting the binary runtime executable code that is incomplete; and
converting the extracted binary runtime executable code into a code of a same code type as received at the blueprint generator.

### Claim 7 (depends on 6)

The computer-implemented method of claim 6, further comprising:
transmitting the converted code from the reverse engineer engine to the orchestration engine;
receiving the converted code from the orchestration engine at a user interface data renderer;
rendering the converted code as one or more integration steps; and
displaying the one or more integration steps on a user interface of the integration flow editor.

### Claim 8 (depends on 5)

The computer-implemented method of claim 5, further comprising:
receiving, at the orchestration engine, the most recently saved input;
rendering the received input via the user interface data renderer; and
displaying the rendered input on the user interface of the integration flow editor.

### Claim 9 (depends on 1)

The computer-implemented method of claim 1, wherein receiving the update to the input further comprises:
receiving a change to at least one data element received as input ay the at least one component.

### Claim 10 (depends on 1)

The computer-implemented method of claim 1, further comprising:
verifying, via the input/output interceptor, the at least one component receives an input.

### Claim 11 (depends on 1)

The computer-implemented method of claim 1, further comprising:
prior to executing the received binary runtime executable code, determining whether a first input is available for receipt by a first one of the at least one component; and
in a case that the first input is available, saving the input.

### Claim 12

A system comprising:
a source system and a target system;
an integration flow renew module;
a computer memory storing processor-executable process steps; and
an integration flow renew computer processor coupled to the computer memory, and in communication with the integration flow renew module and operative to execute the processor-executable process steps to cause the system to:
receive a set of integration steps to transfer data between a first application of the source system and a second application of the target system, wherein the set of integration steps includes execution of at least one component;
transmit the received set of integration steps to a blueprint generator;
convert, at the blueprint generator, the received set of integration steps to a binary runtime executable code;
insert at least two input/output interceptors into the binary runtime executable code;
receive the binary runtime executable code at a runtime component;
execute the received binary runtime executable code at the runtime component using data,
in a case that execution of the at least one component is complete, an output of the executed at least one component is saved;
in a case that execution of the at least one component is incomplete:
receive an update to the data;
re-generate, at the blueprint generator, the binary runtime executable code for one or more an unexecuted integration steps, wherein re-generation is executed from a point when the at least one incomplete component receives the input update; and
execute the re-generated binary runtime executable code.

### Claim 13 (depends on 12)

The system of claim 12, wherein the set of integration steps are received as user interface data at an integration flow editor.

### Claim 14 (depends on 12)

The system of claim 12, further comprising processor-executable process steps to cause the system to, in the case that execution of the at least one component is incomplete,
receive a notification of the incomplete execution at an orchestration engine; and
identify a component where the execution was incomplete.

### Claim 15 (depends on 14)

The system of claim 14, wherein identifying the component where the execution was incomplete further comprises processor-executable process steps to cause the system to:
retrieve a most recently saved input and a most recently saved output; and
determine a given component had an incomplete execution in a case that the given component has an input and no output.

### Claim 16 (depends on 14)

The system of claim 14, further comprising processor-executable process steps to cause the system to:
extract the binary runtime executable code that is incomplete; and
convert the extracted binary runtime executable code into a code of a same code type as received at the blueprint generator.

### Claim 17 (depends on 12)

The system of claim 12, further comprising processor-executable process steps to cause the system to:
prior to execution of the received binary runtime executable code, determine whether a first input is available for receipt by a first one of the at least one component; and
in a case that the first input is available, save the input.

### Claim 18

A non-transitory computer-readable medium storing program code, the program code executable by a computer system to cause the computer system to:
receive a set of integration steps to transfer data between a first application and a second application, wherein the set of integration steps includes execution of at least one component;
transmit the received set of integration steps to a blueprint generator;
convert, at the blueprint generator, the received set of integration steps to a binary runtime executable code;
insert at least two input/output interceptors into the binary runtime executable code;
receive the binary runtime executable code at a runtime component;
execute the received binary runtime executable code at the runtime component using data,
in a case that execution of the at least one component is complete, an output of the executed at least one component is saved;
in a case that execution of the at least one component is incomplete:
receive an update to the data;
re-generate, at the blueprint generator, the binary runtime executable code for one or more an unexecuted integration steps, wherein re-generation is executed from a point when the at least one incomplete component receives the input update; and
execute the re-generated binary runtime executable code.

### Claim 19 (depends on 18)

The non-transitory computer-readable medium of claim 18, further comprising program code to cause the system to, in the case that execution of the at least one component is incomplete,
receive a notification of the incomplete execution;
retrieve a most recently saved input and a most recently saved output; and
determine a given component had an incomplete execution in a case that the given component has an input and no output.

### Claim 20 (depends on 18)

The non-transitory computer-readable medium of claim 18, further comprising program code to cause the system to:
prior to execution of the received binary runtime executable code, determine whether a first input is available for receipt by a first one of the at least one component; and
in a case that the first input is available, save the input.
