Select Two (Multi-Select) Questions

Use a Groovy script to catch exceptions and implement a retry loop with sleep.

Why it fails: While a Groovy script can implement custom retry logic with loops and sleep, it is not the recommended approach when built-in adapter retry settings exist. Scripting retries increases complexity and may not integrate well with the integration flow's error handling. The adapter's retry configuration is simpler and more maintainable.

Use an Exception Subprocess with a Timer step to implement retries.

Why it fails: An Exception Subprocess is triggered when an error occurs, but it does not automatically retry the failed step. You could use a Timer step and a loop, but that is complex and not the standard approach. The adapter's built-in retry configuration is more appropriate and efficient for this scenario.

Add a Content Modifier step to set a header indicating the retry count.

Why it fails: A Content Modifier step can set headers, but it does not control retry logic. The retry mechanism is handled by the adapter or by explicit error handling steps. Setting a header would not trigger retries on its own; it would require custom logic in a script or additional steps.

Use a Splitter step to break the error message into multiple parts for logging

Why it fails: A Splitter is used to decompose a payload into multiple messages, not to handle or log exceptions. The error message from an HTTP failure is typically a single payload, so splitting it adds no value and does not address logging or fallback. It also does not allow the flow to continue with a fallback response, which is the stated goal.

Use a Request Reply step to call the same REST endpoint again without any changes

Why it fails: A Request Reply step inside the Exception Subprocess would call the endpoint again, but if the failure is persistent, it will simply fail again. Retrying without changes or backoff is not a valid exception-handling strategy for specific HTTP errors and does not provide logging or a fallback. It also does not by itself allow the flow to continue with a defined response.

Use a Content Enricher step to merge the original request with the error response

Why it fails: A Content Enricher merges data from an external source into the current message, typically to add fields. It does not provide a mechanism to log errors or to define a fallback response that lets the flow continue. While it could combine payloads, it does not address the requirement of catching specific HTTP errors and continuing with a fallback.

Proxy Type

Why it fails: The proxy type parameter is optional depending on whether the target service resides inside a corporate network accessible via Cloud Connector or directly over the public internet. Default deployments pointing to public endpoints do not strictly require proxy configuration.

EDMX File Repository Path

Why it fails: An EDMX file path is not mandatory since the OData V4 adapter can dynamically fetch the metadata document directly from the service endpoint during design-time or runtime discovery. Manual repository mapping is only used for offline model validation.

Batch Processing Chunk Size

Why it fails: Chunk size only tunes how many records the adapter sends per batch call; it is optional and defaults sensibly. The mandatory receiver parameters are the OData service URL and authentication method, which the stem requires. Batch chunking becomes relevant only when the target service throttles large payloads and you deliberately split them.

An OData API artifact exposing the mapping as a service

Why it fails: An OData API artifact defines an API proxy for external consumers, not an internal reusable mapping or script. It is used for API management scenarios and does not provide a way to embed mapping logic into integration flows. Creating one would add unnecessary complexity and would not achieve code reuse.

A Partner Directory entry storing the script as a binary parameter

Why it fails: The Partner Directory stores partner-specific configuration such as identifiers and binary parameters, but it is not designed to hold executable mapping logic or Groovy scripts for reuse. While scripts can be stored as binary content, this is not the standard or maintainable approach for sharing processing logic across flows.

A Value Mapping artifact containing the target field values

Why it fails: A Value Mapping artifact holds source-to-target value pairs for lookups, not executable mapping logic or scripts. It cannot replace a Message Mapping or a Script Collection. Creating one would not make the mapping step or Groovy script reusable, so it does not fulfil the stated requirement.

Disable token expiry validation on the external API by requesting a token with an infinite lifetime.

Why it fails: The external API controls token lifetime, and a client cannot request an infinite expiry if the authorization server does not support it. Attempting to disable validation would require changing the API, which is outside the developer's control. This measure is not feasible and does not address the requirement to reuse tokens efficiently.

Call the token endpoint before every API request to guarantee a fresh token.

Why it fails: Requesting a new token for every call directly contradicts the goal of avoiding a token request per invocation. It increases latency and load on the authorization server. While it would work functionally, it is inefficient and does not leverage caching, so it fails the stated objective of reducing token requests.

Hard-code the bearer token in the integration flow configuration and update it manually before each expiry.

Why it fails: Hard-coding a token is insecure and operationally fragile. Tokens expire every 30 minutes, so manual updates would be required continuously, and any missed update causes failures. It also exposes credentials in the flow configuration. This approach does not scale and contradicts security best practices, so it is not a valid measure.

Add a Content Modifier to insert the UsernameToken header manually into the SOAP envelope

Why it fails: Manually inserting a WS-Security header via Content Modifier bypasses the adapter's built-in security handling and is error-prone, especially regarding timestamp and nonce generation. The SOAP adapter's WS-Security configuration handles these elements correctly. Manual insertion also risks exposing credentials in logs and does not integrate with the User Credentials artifact.

Enable OAuth 2.0 client credentials in the SOAP adapter's authentication settings

Why it fails: OAuth 2.0 client credentials is a different authentication mechanism than WS-Security UsernameToken. The external service requires UsernameToken, so configuring OAuth would not satisfy its authentication expectations. Additionally, the SOAP adapter's WS-Security settings are separate from OAuth configuration, making this option both incorrect and unrelated to the requirement.

Configure the SOAP adapter to use Proxy Type 'On-Premise' with a Cloud Connector location ID

Why it fails: Proxy Type 'On-Premise' is used when the target service resides behind a Cloud Connector on the customer network. The scenario describes an external SOAP service reachable over the internet, so on-premise proxy settings are unnecessary and would misroute the call. This option does not address authentication or certificate validation.

Configure the SAP Cloud Integration tenant to use the Cloud Connector's location ID.

Why it fails: While the location ID is used in the Cloud Connector configuration, the SAP Cloud Integration tenant does not need to be explicitly configured with it. The Cloud Connector itself is configured with the location ID, and the tenant uses it implicitly through the destination or adapter configuration. This is not a mandatory action for the Cloud Connector setup.

Create a destination in SAP BTP Cockpit that points to the on-premise system.

Why it fails: Creating a destination in SAP BTP Cockpit is necessary for cloud applications to call on-premise systems, but it is not a configuration step of the Cloud Connector itself. The question asks for actions to configure the Cloud Connector, so this is not the correct action. Destinations are configured separately in the BTP subaccount.

Deploy a connectivity proxy in the SAP BTP subaccount.

Why it fails: A connectivity proxy is not required for Cloud Connector integration. The Cloud Connector establishes a secure tunnel directly to SAP BTP, and the connectivity service handles the communication. Deploying a separate proxy is unnecessary and not part of the standard configuration steps.

Configure the receiver adapter to use a best-effort delivery mode so failures are ignored and processing continues.

Why it fails: Best-effort delivery does not guarantee message delivery and would allow failures to pass silently. The scenario demands that a message be removed only after success and that failures be retried, so ignoring failures contradicts the reliability objective and risks losing business data.

Set the JMS queue to 'auto-delete' so that messages are removed immediately after being read by the adapter.

Why it fails: Auto-delete removes messages as soon as they are read, which is the opposite of the requirement. If a downstream step fails, the message would already be gone, causing data loss. This setting undermines reliability rather than ensuring acknowledgement on success.

Increase the JMS queue's maximum message size so large payloads are not rejected during processing.

Why it fails: Queue size limits affect whether a message can be enqueued at all, not whether it is acknowledged after processing or retried on failure. Adjusting the size limit does nothing for the reliability requirement and may be irrelevant if payloads are within limits.

Add a Message Mapping step that transforms the error response into the request payload.

Why it fails: Message Mapping transforms structured data between source and target structures; it does not trigger retries or raise alerts. While mapping an error response could be useful for logging, it does not fulfill either the retry requirement or the alerting requirement described in the scenario.

Configure a JMS queue to store the request and have a separate flow poll it indefinitely.

Why it fails: A JMS queue can decouple and persist messages, but it does not by itself implement retry-on-failure or alerting. Introducing an indefinite polling flow adds architectural complexity without addressing the immediate need to retry a failed API call and alert when retries are exhausted.

Add a Content Modifier that sets the HTTP status code to 200 before the call.

Why it fails: A Content Modifier cannot set the HTTP status code of an outbound call; status codes are returned by the external API. Forcing a value would not influence whether the call succeeds or fails, and it does nothing to implement retry or alerting behavior required by the scenario.

Create a PGP key pair in the tenant keystore and reference it in the SOAP receiver adapter's encryption settings.

Why it fails: PGP keys are used for PGP-based encryption and signing of payloads, not for WS-Security XML signature in SOAP. The SOAP receiver adapter's WS-Security signing uses X.509 certificates and keys from the keystore, not PGP key pairs. Configuring PGP here would not produce the required WS-Security signature.

Add a Message Mapping step that inserts a UsernameToken element into the SOAP header before the receiver call.

Why it fails: Manually mapping a UsernameToken element does not produce a valid WS-Security header with the required namespace, nonce, and timestamp. The SOAP receiver adapter generates the proper WS-Security structures when the authentication option is selected. A mapping-based token would likely be rejected by the external service.

Set the SOAP adapter's message exchange pattern to one-way and add a digital signature to the payload using a Groovy script.

Why it fails: Changing the message exchange pattern affects synchronous versus asynchronous communication, not WS-Security. A Groovy script that signs the payload would not generate a proper WS-Security XML signature in the SOAP header. The external service expects WS-Security, so a payload-level signature would not satisfy the requirement.

Switch the receiver adapter to the SOAP protocol to reduce overhead

Why it fails: Changing the protocol does not address backend processing time and would require rebuilding the request and response handling for a different interface contract. The S/4HANA service being called is exposed as OData, so a SOAP call would not map to the same endpoint and would likely fail outright.

Move the OData call into a Local Integration Process to isolate it

Why it fails: A Local Integration Process is a structural construct for reusing or organizing flow logic, not a resilience mechanism. It does not alter timeout behavior, retry behavior, or backend load, so moving the call there leaves the intermittent timeout condition unchanged.

Disable the CSRF token handling in the adapter to save a round trip

Why it fails: CSRF token handling is required for write operations against S/4HANA OData services. Disabling it would cause the backend to reject the modifying requests with a security error, replacing intermittent timeouts with consistent authorization failures, so it worsens rather than improves resilience.

Enable the Principal Propagation option on the sender adapter so the partner's certificate is forwarded to the backend system.

Why it fails: Principal propagation is a receiver-side concept used to forward the authenticated user identity to an on-premise or backend system, typically combined with Cloud Connector. It does not authenticate the incoming partner at the HTTPS sender; enabling it alone leaves the endpoint without client certificate validation and does not meet the authentication requirement.

Create a service instance of the Process Integration Runtime plan and bind it to the integration flow's deployed artifact.

Why it fails: Process Integration Runtime service instances grant OAuth-based access for runtime APIs and are used by external clients to call integration flows with OAuth tokens. They do not perform client certificate authentication at the sender and are not required for a partner that presents an X.509 certificate, so this action is irrelevant to the scenario.

Deploy an OAuth 2.0 client credentials artifact and reference its token endpoint URL in the sender adapter configuration.

Why it fails: OAuth 2.0 client credentials is a token-based authorization mechanism where the caller obtains an access token from a token endpoint, which is unrelated to mutual TLS client certificate authentication. Configuring it here would not validate the partner's certificate, and the sender adapter's client certificate option would remain unfulfilled, so this action does not satisfy the requirement.

Deploy a User Credentials artifact containing the client ID and client secret.

Why it fails: User Credentials artifacts store username and password pairs for basic authentication, not OAuth 2.0 client credentials. They lack the necessary fields for token endpoint URL and client authentication method. Using User Credentials for OAuth 2.0 would require custom scripting, which is not the standard or secure practice in SAP Cloud Integration.

Store the client secret in a message header and use it directly in the HTTP receiver adapter.

Why it fails: Storing the client secret in a message header exposes it in message logs and monitoring, violating security best practices. The HTTP receiver adapter does not natively support OAuth 2.0 client credentials; it requires the OAuth2 Authorization step to obtain a token. Directly using the secret in the adapter would not perform the token exchange.

Configure the HTTP receiver adapter with the client ID and secret in the 'Authentication' tab.

Why it fails: The HTTP receiver adapter's authentication options include Basic, OAuth2, and others, but for OAuth2 client credentials, it relies on a security material of type 'OAuth2 Client Credentials'. Simply entering the client ID and secret in the adapter is not supported; the adapter expects a reference to a security artifact. The OAuth2 Authorization step is the correct component to handle token retrieval.

Configure the SOAP receiver adapter to throw an exception on fault and let the default error handler return the fault to the sender.

Why it fails: Letting the default error handler return the raw fault gives the sender a generic failure and does not write the fault details to the Message Processing Log in a structured way. The requirement asks for both logging and a custom error, and the default handler satisfies neither in a controllable manner.

Add a Content Modifier step inside the exception subprocess to write the fault text to the message log.

Why it fails: A Content Modifier step can set headers or properties but it does not write to the Message Processing Log. Logging fault details requires a script or a step that explicitly emits a log entry, so a Content Modifier alone would leave the fault text out of the MPL and make diagnosis harder.

Enable 'Allow Chunking' on the SOAP receiver adapter so fault responses are streamed back to the sender.

Why it fails: Allow Chunking controls how large request payloads are streamed to the receiver; it has no bearing on fault handling or error propagation. Enabling it would not log fault details to the Message Processing Log nor produce a custom error response, so it does not satisfy either part of the requirement.

Configure the same OAuth 2.0 client credentials on both adapters

Why it fails: ProcessDirect is an internal adapter used for communication within the same tenant and does not require OAuth 2.0 authentication. OAuth 2.0 client credentials are used for external HTTP-based communication, not for ProcessDirect. Configuring OAuth 2.0 on ProcessDirect adapters is not supported and would not establish the connection; the address matching is what matters.

Enable the 'Allow Synchronous' checkbox on the receiver adapter

Why it fails: The ProcessDirect adapter is inherently synchronous and does not have an 'Allow Synchronous' checkbox. That option is associated with other adapters, such as the XI or SOAP adapter, where synchronous behavior must be explicitly enabled. For ProcessDirect, the synchronous nature is implicit, and no such setting exists. Enabling it is not possible and not required.

Configure a JMS queue name that both adapters reference

Why it fails: JMS queues are used for asynchronous messaging and are not part of the ProcessDirect adapter configuration. ProcessDirect does not use JMS queues to route messages. Referencing a JMS queue name would be irrelevant and would not establish the synchronous connection. The correct approach is to use matching addresses within the same tenant.

Set up a trust relationship between the Cloud Connector and the on-premise system's certificate authority (CA).

Why it fails: While a trust relationship is important for secure communication, principal propagation specifically requires configuring the Cloud Connector to trust the SAP Cloud Integration tenant's certificate for user mapping. Setting up trust with the on-premise CA is part of the overall setup but is not the specific configuration for principal propagation. The key is to configure the Cloud Connector to accept the principal from the cloud and map it to an on-premise user.

Install a client certificate on the Cloud Connector that is trusted by the on-premise system.

Why it fails: While a client certificate may be used for secure communication, principal propagation primarily relies on the Cloud Connector's ability to forward the user identity. The Cloud Connector uses its own certificate to establish a secure tunnel, but the user identity is propagated via a separate mechanism, often SAML. Installing a client certificate is not the specific configuration for enabling principal propagation; it is part of the general trust setup.

Configure the on-premise system to accept assertions from the Cloud Connector's certificate.

Why it fails: The on-premise system must be configured to trust the Cloud Connector's certificate, but this is typically done as part of the overall trust setup. Principal propagation involves the Cloud Connector acting as a proxy and using the user's identity. The on-premise system must be configured to accept the propagated principal, but this is usually done via SAML or certificate-based authentication. The specific Cloud Connector configuration is the ACL and system mapping, not the on-premise system's assertion acceptance.

Enable 'Keep Alive' on the JMS adapter and set the acknowledgment mode to 'Auto' to reduce connection overhead during high-volume processing.

Why it fails: Keep Alive and Auto acknowledgment are performance and convenience settings that do not provide transactional reliability. Auto acknowledgment acknowledges messages before processing completes, which is precisely the condition that leads to message loss on failure. This option would undermine both requirements and is not a valid reliability configuration for the described scenario.

Increase the JMS queue's maximum message size and set the adapter's polling interval to zero so messages are consumed as fast as possible.

Why it fails: Maximum message size and polling interval affect capacity and throughput, not reliability. A zero polling interval may increase load without improving delivery guarantees, and none of these settings prevent loss on failure or handle a poison message. This option addresses performance tuning rather than the transactional and retry semantics the scenario requires.

Set the JMS transaction type to 'None' and enable the 'Use JMS Message ID as Correlation ID' option on the adapter.

Why it fails: Setting transaction type to None means the message is acknowledged as soon as it is read, so a downstream failure after acknowledgment results in permanent message loss. The correlation ID option only affects how messages are correlated, not delivery guarantees. This combination directly contradicts the requirement to avoid message loss on processing failure.

Headers in the message model are immutable, so the script must use a Content Modifier step to read the BusinessUnit header value.

Why it fails: Headers can be read directly in Groovy scripts through the Message API; they are not inaccessible from script. While a Content Modifier can also read headers, it is not required. The statement that headers are immutable and must be read via Content Modifier is incorrect. Scripts routinely access headers, so this option misrepresents the message model and the available APIs.

The script must use message.getBody() to obtain the header value, because headers and body share the same storage in the message model.

Why it fails: Headers and body are distinct parts of the message model. getBody() returns the payload, not headers. Using it to obtain a header value is incorrect and would return the body content. Headers must be accessed through getHeaders(). This option confuses the two message components and would not retrieve BusinessUnit, so it fails the scenario.

The script can only read headers that were defined in the integration flow's sender adapter, and custom headers added by a Content Modifier are invisible to Groovy.

Why it fails: Custom headers added by a Content Modifier or any earlier step are visible to subsequent Groovy scripts through the Message API. There is no restriction limiting script access to only sender-adapter headers. This option misstates the visibility rules and would incorrectly lead the developer to avoid a valid approach. Headers flow through the message and remain accessible unless explicitly removed.

Switch the receiver adapter from HTTPS to HTTP to bypass rate limiting.

Why it fails: Switching from HTTPS to HTTP does not affect rate limiting; the external API enforces limits based on the caller identity and request rate, not the transport protocol. Using HTTP would also reduce security and is not a valid solution. This action fails to address the root cause and introduces additional risk without resolving the 429 errors.

Increase the JVM heap size of the tenant to handle more concurrent requests.

Why it fails: Increasing heap size addresses memory pressure, not rate limiting. HTTP 429 is returned by the external API when the caller exceeds its allowed request rate, so more memory on the tenant does not reduce the number of calls or make the external API accept them. This action does not resolve the root cause and is not a valid resilience measure for rate limiting.

Disable the CSRF protection on the sender adapter to reduce processing overhead.

Why it fails: CSRF protection is relevant to inbound sender adapters, not outbound calls to an external API. Disabling it would not influence the external API's rate limiting behavior. This action is unrelated to the scenario and does not improve resilience against HTTP 429 responses. It may also weaken security for inbound requests, making it an inappropriate choice.

Install a reverse proxy directly in front of the Cloud Integration tenant runtime node

Why it fails: A reverse proxy in front of the tenant runtime does not participate in the Cloud Connector tunnel and adds no authentication or mapping. The Cloud Connector itself performs the reverse-proxy role on-premise. Such a proxy would be relevant only for exposing the tenant's own endpoints, not for reaching on-premise systems.

Open inbound firewall ports on the corporate network to allow direct public internet traffic to the backend system

Why it fails: The Cloud Connector establishes an outbound-only secure tunnel from the on-premise network, so no inbound public ports are opened. Direct internet exposure of the backend is what the Cloud Connector exists to eliminate. Inbound firewall rules would be relevant only for systems deliberately published to the internet.

Store backend credentials permanently inside the integration flow script using plain text properties

Why it fails: Plain-text credentials in scripts expose secrets to anyone reading the integration flow and breach secure-storage requirements. The Cloud Connector scenario expects credentials held in a Security Material artefact. Plain-text properties would only be acceptable for non-sensitive, non-authentication configuration values.