SOA Design & Architecture Lab : S90.09

Service Consumer A sends a message with a business document to Service A (1), which
writes the business document to Database A (2). Service A then forwards the business
document to Service B (3), which writes the business document to Database B (4).
Service B then responds to Service A with a message containing a failure or success code
(5) after which Service A responds to Service Consumer A with a message containing a
failure or success code (6). Upon receiving the message, Service Consumer A updates a
log table in Database B (7). The log entry is comprised of the entire business document.
Database A is dedicated to the Service A service architecture and Database B is a shared
database.

There are two problems with this service composition architecture that you are asked to
address: First, both Service Consumer A and Service B need to transform the business
document data from an XML format to a proprietary Comma Separated Value (CSV) in
order to write the data to Database B.
This has led to redundant data format transformation logic that has been difficult to keep in synch when Database B changes. Secondly, Service
A is an entity service that is being reused by several other service compositions. It has
lately developed reliability problems that have caused the service to become unavailable
for extended periods. What steps can be taken to solve these problems?

• A. The Legacy Wrapper pattern can be applied so that data access to Database B is
  separated into a new wrapper utility service. This way, the Data Format Transformation
  pattern only needs to be applied within the logic of this new service which will expose a
  standardized contract that both Service Consumer A and Service B can access. The
  Asynchronous Queuing pattern can be applied so that messaging queues are established
  between Service Consumer A and Service A and between Service A and Service B . The
  Service Autonomy principle can be further applied to Service A in order to establish a more
  isolated and reliable surrounding infrastructure.
• B. None of the above.
• C. The service composition can be redesigned with the application of the Contract
  Centralization pattern so that instead of writing the business document to Database B,
  Service Consumer A sends the business document to Service B instead. This way, Service
  B would provide the only location where data format transformation logic for Database B
  needs to be carried out, which further supports the application of the Service Reusability
  principle. The Reliable Messaging pattern can be applied so that acknowledgements are
  passed between Service Consumer A and Service A and between Service A and Service B
  . The Service Composability principle can be further applied to Service A in order to
  optimize its service architecture for improved participation in multiple service compositions.
• D. The Legacy Wrapper pattern can be applied so that data access to Database B is
  separated into a new wrapper utility service. This way, the Data Format Transformation
  pattern only needs to be applied within the logic of this new service which will expose a
  standardized contract that both Service Consumer A and Service B can access. The
  Reliable Messaging pattern can be applied so that acknowledgements are passed between
  Service Consumer A and Service A and between Service A and Service B . The Service
  Composability principle can be further applied to Service A in order to optimize its service
  architecture for improved participation in multiple service compositions.

Service A is an orchestrated task service that is invoked by a separate composition initiator
(1) and then sends a request message to Service C (2). Service C queries Database B to
retrieve a large data record (3) and provides this data in a response message that is sent
back to Service A.
Service A temporarily stores this data in a central state database (4) and
then sends a request message to Service D (5), which accesses a legacy system API to
retrieve a data value (6). Service D then sends this data value in a response message back
to Service A.
The data in the state database is subsequently retrieved by Service A (7) and
merged with the newly received data value. This combined data is written to Database A
(8), which triggers an event that results in the invocation of Service B (9).
Service B is an orchestrated task service that sends a request message to Service D (10).
which accesses a legacy system API to retrieve a data value (11) and then sends this data
value in a response message back to Service B.
Service B temporarily stores this data in a
central state database (12) and then sends a request message to Service E (13), which
performs a runtime calculation and then responds with the calculated data value back to
Service B.
The data in the state database is then retrieved by Service B (14) and merged
with the calculated data value. Service B then uses the merged data to complete its
business task.
The following specific problems and requirements exist:
* Database B uses a proprietary data format that is not compliant with the XML
format used by all of the services in this service composition architecture This
incompatibility needs to be solved in order to enable the described service
message exchanges.
* The service contract provided by Service D does not comply with the data model
standards that were applied to the other services and therefore uses a different
data model to represent the same type of data that is exchanged. This
incompatibility needs to be solved in order to enable communication with Service
D.
* Database B is a shared database that can be accessed by other services and
applications within the IT enterprise, which causes unpredictable runtime
performance. This performance problem needs to be solved in order to make the
runtime behavior of Service C more predictable.
* For performance and maintenance reasons, Service A and Service B need to be
deployed in the same physical environment where they can share a common state
database.

Upon reviewing these requirements it becomes evident to you that the Enterprise Service
Bus compound pattern will need to be applied. However, there are additional requirements
that need to be fulfilled. To build this service composition architecture, which patterns that
is not associated with the Enterprise Service Bus compound pattern need to also be
applied? (Be sure to choose only those patterns that relate directly to the requirements
described above. Patterns associated with the Enterprise Service Bus compound pattern
include both the required or core patterns that are part of the basic compound pattern and
the optional patterns that can extend the basic compound pattern.)

• A. Intermediate Routing
• B. Data Format Transformation
• C. State Repository
• D. Compensating Service Transaction
• E. Redundant Implementation
• F. Event-Driven Messaging
• G. Service Data Replication
• H. Policy Centralization
• I. Protocol Bridging
• J. Data Model Transformation
• K. Reliable Messaging
• L. Atomic Service Transaction
• M. Process Centralization

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

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