SOA S90.09 Value Pack (Frequently Bought Together)

Service A is a task service that sends Service B a message (2) requesting that Service B
return data back to Service A in a response message (3). Depending on the response
received. Service A may be required to send a message to Service C (4) for which it
requires no response.
Before it contacts Service B, Service A must first retrieve a list of code values from its own
database (1) and then place this data into its own memory. If it turns out that it must send a
message to Service C, then Service A must combine the data it receives from Service B
with the data from the code value list in order to create the message it sends to Service C.
If Service A is not required to invoke Service C, it can complete its task by discarding the
code values.
Service A and Service C reside in Service Inventory A.
Service B resides in Service Inventory B.

You are told that the services in Service Inventory A were designed with service contracts
based on different design standards than the services in Service Inventory B.
As a result,Service A and Service B use different data models to represent the data they need to
exchange. Therefore, Service A and Service B cannot currently communicate.
Furthermore, Service C is an agnostic service that is heavily accessed by many concurrent
service consumers. Service C frequently reaches its usage thresholds during which it is not
available and messages sent to it are not received. How can this service composition
architecture be changed to avoid these problems?

• A. None of the above.
• B. The Data Model Transformation pattern can be applied by establishing an intermediate
  processing layer between Service A and Service B that can transform a message from one
  data model to another at runtime. The Intermediate Routing and Service Agent patterns
  can be applied so that when Service B sends a response message, a service agent can
  intercept the message and, based on its contents, either forward the message to Service A
  or route the message to Service C . The Service Statelessness principle can be applied
  with the help of the State Repository pattern so that Service A can write the code value
  data to a state database while it is waiting for Service B to respond.
• C. The Data Model Transformation pattern can be applied by establishing an intermediate
  processing layer between Service A and Service B that can transform a message from one
  data model to another at runtime. The Asynchronous Queuing pattern can be applied to
  establish an intermediate queue between Service A and Service C so that when Service A
  needs to send a message to Service C, the queue will store the message and retransmit it
  to Service C until it is successfully delivered. The Service Autonomy principle can be
  further applied to Service C together with the Redundant Implementation pattern to help
  establish a more reliable and scalable service architecture.
• D. The Data Model Transformation pattern can be applied by establishing an intermediate
  processing layer between Service A and Service B that can transform a message from one
  data model to another at runtime. The Intermediate Routing and Service Agent patterns
  can be applied so that when Service B sends a response message, a service agent can
  intercept the message and, based on its contents, either forward the message to Service A
  or route the message to Service C . The Service Autonomy principle can be further applied
  to Service C together with the Redundant Implementation pattern to help establish a more
  reliable and scalable service architecture.

Service A is an entity service that provides a Get capability that returns a data value that is
frequently changed.
Service Consumer A invokes Service A in order to request this data value (1). For Service
A to carry out this request, it must invoke Service B (2), a utility service that interacts (3.4)
with the database in which the data value is stored, Regardless of whether the data value
changed. Service B returns the latest value to Service A (5), and Service A returns the
latest value to Service Consumer A (6).
The data value is changed when the legacy client program updates the database (7). When
this change happens is not predictable. Note also that Service A and Service B are not
always available at the same time.
Any time the data value changes. Service Consumer A needs to receive it as soon as
possible. Therefore, Service Consumer A initiates the message exchange shown in the
Figure several times a day. When it receives the same data value as before, the response
from Service A is ignored. When Service A provides an updated data value, Service
Consumer A can process it to carry out its task.

Because Service A and Service B are not always available at the same times, messages
are getting lost and several invocation attempts by Service Consumer A fail. What steps
can be taken to solve this problem?

• A. The Asynchronous Queuing pattern can be applied so that messaging queues are
  established between Service A and Service B and between Service Consumer A and
  Service A . This way, messages are never lost due to the unavailability of Service A or
  Service B .
• B. None of the above.
• C. The Asynchronous Queuing pattern can be applied so that a messaging queue is
  established between Service A and Service B . This way, messages are never lost due to
  the unavailability of Service A or Service B . The Service Agent pattern can be further
  applied to establish a service agent that makes a log entry and issues a notification when
  re-transmission attempts by the messaging queue exceeds a pre-determined quantity.
• D. The Asynchronous Queuing pattern can be applied so that a messaging queue is
  established between Service Consumer A and Service A.
  This way, messages are never lost due to the unavailability of Service A or Service B.
  The Service Agent pattern can be
  further applied to establish a service agent that makes a log entry each time a runtime exception occurs.

Service A is a utility service that provides generic data access logic to a database that
contains data that is periodically replicated from a shared database (1). Because the
Standardized Service Contract principle was applied to the design of Service A, its service
contract has been fully standardized.
Service A is being accessed by three service consumers. Service Consumer A accesses a
component that is part of the Service A implementation by invoking it directly (2). Service
Consumer B invokes Service A by accessing its service contract (3). Service Consumer C
directly accesses the replicated database that is part of the Service A implementation (4).

You've been told that the reason Service Consumers A and C bypass the published
Service A service contract is because, for security reasons, they are not allowed to access
a subset of the operations in the WSDL definition that expresses the service contract. How
can the Service A architecture be changed to enforce these security restrictions while
avoiding negative forms of coupling?

• A. The Contract Centralization pattern can be applied to force service consumers to access
  the Service A architecture via its published service contract only. The Service Loose
  Coupling principle can then be applied to ensure that the centralized service contract does
  not contain any content that is dependent on or derived from the underlying service
  implementation.
• B. None of the above.
• C. The Concurrent Contracts pattern can be applied to Service A in order to establish one
  or more alternative service contracts. This allows service consumers with different levels of
  security clearance to continue accessing the service logic via its published service
  contracts.
• D. The Contract Centralization pattern can be applied to force all service consumers to
  access the Service A architecture via its published service contract. This will prevent
  negative forms of coupling that could lead to problems when the database is replaced. The
  Service Abstraction principle can then be applied to hide underlying service architecture
  details so that future service consumers cannot be designed to access any part of the
  underlying service implementation.

Service A is a task service that is required to carry out a series of updates to a set of
databases in order to complete a task. To perform the database updates Service A must
interact with three other services, each of which provides standardized data access
capabilities.
Service A sends its first update request message to Service B (1), which then responds
with a message containing a success or failure code (2). Service A then sends its second
update request message to Service C (3), which also responds with a message containing
a success or failure code (4). Finally, Service A sends a request message to Service D (5),
which responds with its own message containing a success or failure code (6).

You've been given a requirement that all database updates must either be completed
successfully or not at all. This means that if any of the three response messages received
by Service A contain a failure code, all of the updates carried out until that point must be
reversed. Note that if Service A does not receive a response message back from Services
B, C, or D, it must assume that a failure has occurred. How can this service composition
architecture be changed to fulfill these requirements?

• A. The Compensating Service Transaction can be applied to Service A so that when any
  one response message containing a failure code is received by Service A, it can invoke
  exception handling logic that will log the failed database updates. The Service Loose
  Coupling principle can be further applied to ensure that Services B, C, or D are not
  indirectly coupled to the exception handling logic, especially if Service A requires additional
  access to Services B, C, or D in order to collect more information for logging purposes.
• B. None of the above.
• C. The Atomic Service Transaction pattern can be applied individually to Services B, C,
  and D so that each of these services performs its own database update within the scope of
  an atomic transaction. If anyone update fails, that change can be rolled back on that
  database. Furthermore, the Service Loose Coupling principle can be applied to ensure that
  Service A is kept out of the scope of the atomic transaction so that it is not negatively
  coupled to the proprietary database technologies that are required to enable the atomic
  transaction functionality.
• D. The Reliable Messaging pattern can be applied to guarantee the delivery of positive or
  negative acknowledgements. This way, Service A will always be informed of whether a
  failure condition has occurred with any of the database updates performed by Services B,
  C, and D.
  Furthermore, the Service Loose Coupling principle can be applied to ensure that
  the request and response messages exchanged by the services do not contain any
  implementation details that would indirectly couple Service A to any of the databases.