Service Consumer A sends a message to Service A.
There are currently three duplicate implementations of Service A (Implementation 1, Implementation 2, Implementation 3).
The message sent by Service Consumer A is intercepted by Service Agent A (1), which
determines at runtime which implementation of Service A to forward the message to.
All three implementations of Service A reside on the same physical server.

You are told that despite the fact that duplicate implementations of Service A exist,
performance is still poor at times. Also, you are informed that a new service capability will
soon need to be added to Service A that will introduce functionality that will require access
to a shared database that is used by many other clients and applications in the IT
enterprise. This is expected to add further performance demands on Service A . How can
this service architecture be changed to improve performance in preparation for the addition
of the new service capability?

• A. The Service Loose Coupling principle is applied together with the Standardized Service
  Contract principle to ensure that Service Consumer A is not indirectly coupled to the shared
  database after the new service capability is added to the service contract. The Legacy
  Wrapper pattern can be applied to establish a new utility service that will provide
  standardized data access service capabilities for the shared database.
• B. The Service Autonomy principle is applied to further isolate the individual
  implementations of Service A by separating them onto different physical servers. When the
  new service capability is added, the Service Data Replication pattern is applied to give
  each implementation of Service A its own copy of the data it requires from the shared
  database.
• C. The Standardized Service Contract principle is applied to ensure that the new service
  capability extends the existing service contract in a manner that is compliant with current
  design standards. The Redundant Implementation pattern is applied to establish separate
  implementations of Service A that include duplicate databases with copies of the data that
  Service A requires from the shared database.
• D. None of the above.

Service Consumer A sends Service A a message containing a business document (1). The
business document is received by Component A, which keeps the business document in
memory and forwards a copy to Component B (3). Component B first writes portions of the
business document to Database A (4).
Component B writes the entire business document to Database B and then uses some of
the data values from the business document as query parameters to retrieve new data from
Database B (5).
Next, Component B returns the new data back to Component A (6), which merges it
together with the original business document it has been keeping in memory and then
writes the combined data to Database C (7). The Service A service capability invoked by
Service Consumer A requires a synchronous request-response data exchange. Therefore,
based on the outcome of the last database update, Service A returns a message with a
success or failure code back to Service Consumer A (8).
Databases A and B are shared and Database C is dedicated to the Service A service
architecture.

There are several problems with this architecture: First, the response time of Database A is
often poor, resulting in Component B taking too much time to provide a response to
Component A.
This results in Component A consuming too many runtime resources while it
holds the business document in memory and it also causes unreasonable delays in
responding to Service Consumer A.
Additionally, Database B is being replaced with a different database product that supports a proprietary file format. This will disable the
current interaction between Component B and the new Database B.
What steps can be taken to solve these problems?

• A. The State Repository pattern is applied so that Component A can defer the business
  document data to a state database while it waits for a response from Component B.
  The Asynchronous Queuing pattern can be applied so that a messaging queue is established
  between Service Consumer A and Service A, thereby guaranteeing delivery and avoiding
  Service Consumer A from being tied up too long waiting for Service A to respond. Finally,
  the Data Format Transformation pattern can be applied to enable Component B to convert
  to and from the new proprietary file format introduced by the database product that is
  replacing Database B.
• B. The State Repository pattern is applied so that Component A can defer the business
  document data to a state database while it waits for a response from Component B.
  The Service Data Replication pattern is applied so that Component B can interact with a
  database that is replicated from the shared Database A.
  This will improve performance and reliability that will affect both Component A and Service Consumer A.
  Finally, the Legacy Wrapper pattern is applied so that Database B is wrapped in a standardized contract. This
  will establish a new wrapper utility service that will allow Database B to be replaced with a
  different database product without affecting Service A . Furthermore, the Data Format
  Transformation pattern can be applied within the new wrapper utility service to enable it to
  convert to and from the new proprietary file format.
• C. The Legacy Wrapper pattern is applied so that Database B is wrapped in a standardized
  contract. This will establish a new wrapper utility service that will allow Database B to be
  replaced with a different database product without affecting Service A . The Data Format
  Transformation pattern can be applied within the new wrapper utility service to enable it to
  convert to and from the new proprietary file format. The Service Data Replication pattern is
  applied so that Component B can interact with a database that is replicated from the
  shared Database B, regardless of what database product is used to replace Database B.
  The Service Abstraction principle can be further applied to hide the implementation details,
  including the changes mentioned in this solution, from Service Consumer A.
• D. None of the above.

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 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.
• B. 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.
• C. 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.
• D. None of the above.

Our service inventory contains the following three services that provide invoice-related data
access capabilities: Invoice, InvProc, and Proclnv. These services were created at different
times by different project teams and were not required to comply to any design standards.
Therefore each of these services has a different data model for representing invoice data.
Currently each of these three services has one service consumer: Service Consumer A
accesses the Invoice service(1). Service Consumer B (2) accesses the InvProc service,
and Service Consumer C (3) accesses the Proclnv service. Each service consumer
invokes a data access capability of an invoice-related service, requiring that service to
interact with the shared accounting database that is used by all invoice-related services (4,
5, 6).
Additionally, Service Consumer D was designed to access invoice data from the shared
accounting database directly (7), (Within the context of this architecture. Service Consumer
D is labeled as a service consumer because it is accessing a resource that is related to the
illustrated service architectures.)

Assuming that the Invoice service, InvProc service, and ProcInv service are part of the
same service inventory, what steps would be required to fully apply the Official Endpoint
pattern?

• A. One of the invoice-related services needs to be chosen as the official service providing
  invoice data access capabilities. Service Consumers A, B, and C then need to be
  redesigned to only access the chosen invoice-related service. Because Service Consumer
  D does not rely on an invoice-related service, it is not affected by the Official Endpoint
  pattern and can continue to access the accounting database directly. The Service
  Abstraction principle can be further applied to hide the existence of the shared accounting
  database and other implementation details from current and future service consumers.
• B. Because Service Consumers A, B, and C are already carrying out their data access via
  published contracts, they are not affected by the Official Endpoint pattern. Service
  Consumer D needs to be redesigned to not access the shared accounting database
  directly, but to perform its data access by interacting with the official invoice-related service.
  The Service Abstraction principle can be further applied to hide the existence of the shared
  accounting database and other implementation details from current and future service
  consumers.
• C. One of the invoice-related services needs to be chosen as the official service providing
  invoice data access capabilities. Service Consumers A, B, and C then need to be
  redesigned to only access the chosen invoice-related service. Service Consumer D also
  needs to be redesigned to not access the shared accounting database directly, but to also
  perform its data access by interacting with the official invoice-related service. The Service
  Abstraction principle can be further applied to hide the existence of the shared accounting
  database and other implementation details from current and future service consumers.
• D. None of the above.