Services A, B, and C are non-agnostic task services. Service A and Service B use the
same shared state database to defer their state data at runtime.
An assessment of these three services reveals that each contains some agnostic logic, but
because it is bundled together with the non-agnostic logic, the agnostic logic cannot be
made available for reuse.
The assessment also determines that because Service A and Service B and the shared
state database are each located in physically separate environments, the remote
communication required for Service A and Service B to interact with the shared state
database is causing an unreasonable decrease in runtime performance.

How can the application of the Orchestration pattern improve this architecture?

• A. The application of the Orchestration pattern will result in an environment whereby the
  State Repository and Service Data Replication patterns are naturally applied, allowing the
  shared state database to be replicated for Services A and B so that each task service can
  have its own dedicated state database. The Process Centralization pattern can also be
  applied to Services A and B, so that their logic is physically centralized, turning them into
  orchestrated task services.
• B. This database can be made available as a local part of the environment so that Services
  A and B can avoid remote communication.
• C. None of the above.
• D. The application of the Orchestration pattern will result in an environment whereby the
  Compensating Service Transaction is naturally applied, resulting in the opportunity to
  create sophisticated exception logic that can be used to compensate for the performance
  problems caused by Services A and B having to remotely access the state database. The
  Process Abstraction and Service Broker patterns are also naturally applied, enabling the
  separation of non-agnostic logic and agnostic logic while providing common transformation
  functions required to overcome any disparity in the service contracts that will need to be
  created for the new agnostic services.
• E. The application of the Orchestration pattern will result in an environment whereby the
  Process Abstraction and Process Centralization patterns are naturally applied to Services
  A, B, and C, resulting in a clean separation of non-agnostic task services from newly
  designed agnostic services with reuse potential. Also, the State Repository pattern can be
  applied by the availability of a central state database that can be shared by Services A and

The architecture for Service A displayed in the Figure shows how the core logic of Service
A has expanded over time to connect to a database and a proprietary legacy system (1)
and to support two separate service contracts (2) that are accessed by different service
consumers.
The service contracts are fully decoupled from the service logic. The service logic is
therefore coupled to the service contracts and to the underlying implementation resources
(the database and the legacy system).
Service A currently has three service consumers. Service Consumer A and Service
Consumer B access Service A's two service contracts (3, 4). Service Consumer C
bypasses the service contracts and accesses the service logic directly (5).

You are told that the database and legacy system that are currently being used by Service
A are being replaced with different products. The two service contracts are completely
decoupled from the core service logic, but there is still a concern that the introduction of the
new products will cause the core service logic to behave differently than before. What steps
can be taken to change the Service A architecture in preparation for the introduction of the
new products so that the impact on Service Consumers A, B, and C is minimized?

• A. A third service contract can be added together with the application of the Contract
  Centralization pattern. This will force Service Consumer C to access Service A via the new
  service contract. The Service Facade pattern can be applied to position a Facade
  component between the new service contract and Service Consumer C in order to regulate
  the behavior of Service A . The Service Abstraction principle can be applied to hide the
  implementation details of Service A so that no future service consumers are designed to
  access any of Service A's underlying resources directly.
• B. None of the above.
• C. The Service Facade pattern can be applied to position Facade components between the
  core service logic and the two service contracts. These Facade components will be
  designed to regulate the behavior of Service A . The Contract Centralization pattern can
  also be applied to force Service Consumer C to access Service A via one of its existing
  service contracts.
• D. The Service Abstraction principle can be applied to hide the implementation details from
  the core service logic of Service A, thereby shielding this logic from changes to the
  implementation. In support of this, the Service Facade pattern can be applied to position
  Facade components between the core service logic and Service Consumers A and B.
  These Facade components will be designed to regulate the behavior of Service A . The
  Contract Centralization pattern can be applied to force Service Consumer C to access
  Service A via one of its existing service contracts.

When Service A receives a message from Service Consumer A(1),the message is
processed by Component A.
This component first invokes Component B (2), which uses values from the message to query Database A in order to retrieve additional data.
Component B then returns the additional data to Component A.
Component A then invokes Component C (3), which interacts with the API of a legacy
system to retrieve a new data value. Component C then returns the data value back to
Component A.
Next, Component A sends some of the data it has accumulated to Component D (4), which
writes the data to a text file that is placed in a specific folder. Component D then waits until
this file is imported into a different system via a regularly scheduled batch import. Upon
completion of the import, Component D returns a success or failure code back to
Component A.
Component A finally sends a response to Service Consumer A (5) containing all of the data
collected so far and Service Consumer A writes all of the data to Database B (6).
Components A, B, C.
and D belong to the Service A service architecture. Database A, the legacy system, and the file folders are shared resources within the IT enterprise.

Service A is a task service that completes an entire business task on its own without having
to compose other services. However, you have received many complaints about the
reliability of Service A . Specifically, it has three problems. First, when Component B
accesses Database A, it may not receive a response for several minutes when the
database is being accessed by other applications in the IT enterprise. Secondly, the legacy
system accessed by Component C frequently crashes and therefore becomes unavailable
for extended periods of time. Third, for Component D to respond to Component A, it must
first wait for the batch import of the files to occur. This can take several minutes during
which Service Consumer A remains stateful and consumes excessive memory. What steps
can be taken to address these three problems?

• A. The Service Data Replication pattern can be applied so that Component B can access a
  replicated database instead of having to access the shared Database A directly. The
  Legacy Wrapper pattern can be applied so that Component C is separated into a separate
  service that acts as a wrapper of the legacy system API. Next, the Reliable Messaging
  pattern can be applied so that acknowledgements are issued from the new wrapper service
  to Component A, thereby enabling notifying Component A during times when the legacy
  system is unavailable. Finally, Component D is separated into a separate service and the
  Event-Driven Messaging pattern is applied to establish a publisher-subscriber relationship
  between this new service and Component A.
  The interaction between Service Consumer A and Component A is then redesigned so that Component A first interacts with Component
  B and the new wrapper service. Service A then issues a final message back to Service
  Consumer A.
• B. None of the above.
• C. The Legacy Wrapper pattern can be applied so that Component B is separated to wrap
  the shared database, thereby allowing Component A to interact with this new service
  instead of directly interacting with the database. The Legacy Wrapper pattern can be
  applied again so that Component C is separated into a separate service that acts as a
  wrapper of the legacy system API. Component D can then be separated into a separate
  service and the Event-Driven Messaging pattern can be applied to establish a publisher-
  subscriber relationship between this new service and Component A and between Service A
  and Service Consumer A.
  The interaction between Service Consumer A and Component A is then redesigned so that Component A issues a message back to Service Consumer A
  when the event related to the batch import is triggered.
• D. The Service Data Replication pattern can be applied so that Component B can access a
  replicated database instead of having to access the shared Database A directly. The
  Legacy Wrapper pattern can be applied so that Component C is separated into a separate
  service that acts as a wrapper of the legacy system API. Next, the Asynchronous Queuing
  pattern can be applied so that a messaging queue is positioned between Component A and
  the new wrapper service, thereby enabling communication during times when the legacy
  system is unavailable. Finally, Component D is separated into a new service and the
  Event-Driven Messaging pattern is applied to establish a publisher-subscriber relationship
  between this service and Component A and between Service A and Service Consumer A.
  The interaction logic is redesigned as follows: Component A interacts with Component B,
  the new wrapper service, and then issues a request to the new event-driven service. Upon
  receiving a response triggered by the event related to the batch import, Service A responds
  to Service Consumer A.

Service A is an entity service with a functional context dedicated to invoice-related
processing. Service B is a utility service that provides generic data access to a database.
In this service composition architecture, Service Consumer A sends a SOAP message
containing an invoice XML document to Service A(1). Service A then sends the invoice
XML document to Service B (2), which then writes the invoice document to a database.
The data model used by Service Consumer A to represent the invoice document is based
on XML Schema A.
The service contract of Service A is designed to accept invoice documents based on XML Schema B.
The service contract for Service B is designed to accept invoice documents based on XML Schema A.
The database to which Service B needs to write the invoice record only accepts entire business documents in Comma
Separated Value (CSV) format.

Due to the incompatibility of the XML schemas used by the services, the sending of the
invoice document from Service Consumer A through to Service B cannot be accomplished
using the services as they currently exist. Assuming that the Contract Centralization pattern
is being applied and that the Logic Centralization is not being applied, what steps can be
taken to enable the sending of the invoice document from Service Consumer A to the
database without adding logic that will increase the runtime performance requirements of
the service composition?

• A. Service Consumer A can be redesigned to use XML Schema B so that the SOAP
  message it sends is compliant with the service contract of Service A . The Data Model
  Transformation pattern can then be applied to transform the SOAP message sent by
  Service A so that it conforms to the XML Schema A used by Service B.
  The Standardized Service Contract principle must then be applied to Service B and Service Consumer A so
  that the invoice XML document is optimized to avoid unnecessary validation.
• B. Service Consumer A can be redesigned to write the invoice document directly to the
  database. This reduces performance requirements by avoiding the involvement of Service
  A and Service B . It further supports the application of the Service Abstraction principle by
  ensuring that Service Consumer A hides the details of the data access logic required to
  write to the database.
• C. The service composition can be redesigned so that Service Consumer A sends the
  invoice document directly to Service B.
  Because Service Consumer A and Service B use XML Schema A, the need for transformation logic is avoided. This naturally applies the
  Service Loose Coupling principle because Service Consumer A is not required to send the
  invoice document in a format that is compliant with the database used by Service B.
• D. None of the above.