Home > Articles > Programming > Java

  • Print
  • + Share This
This chapter is from the book

SOAP Intermediaries

So far, we've addressed SOAP headers as a means for vertical extensibility within SOAP messages. There is another related notion, however: horizontal extensibility. Whereas vertical extensibility is about the ability to introduce new pieces of information within a SOAP message, horizontal extensibility is about targeting different parts of the same SOAP message to different recipients. Horizontal extensibility is provided by SOAP intermediaries.

The Need for Intermediaries

SOAP intermediaries are applications that can process parts of a SOAP message as it travels from its origination point to its final destination point. The route taken by a SOAP message, including all intermediaries it passes through, is called the SOAP message path (see Figure 3.2).

Figure 3.2Figure 3.2 The SOAP message path

Intermediaries can both accept and forward SOAP messages, and they usually do some form of message processing as well. Three key use-cases define the need for SOAP intermediaries: crossing trust domains, ensuring scalability, and providing value-added services along the SOAP message path.

Crossing trust domains is a common issue faced while implementing security in distributed systems. Consider the relation between a corporate or departmental network and the Internet. For small organizations, it's likely that the IT department has put most computers on the network within a single trusted security domain. Employees can see their co-workers' computers as well as the IT servers, and they can freely exchange information between them without the need for separate logons. On the other hand, the corporate network probably treats all computers on the Internet as part of a separate security domain that isn't trusted. Before an Internet request reaches the network, it needs to cross from its untrustworthy domain to the trusted domain of the internal network. Corporate firewalls and virtual private network (VPN) gateways guard the network: Their job is to let some requests cross the trust domain boundary and deny access to others.

Another important need for intermediaries arises because of the scalability requirements of distributed systems. A simplistic view of distributed systems could identify two types of entities: those that request work to be done (clients) and those that do the work (servers). Clients send messages directly to the servers they want to communicate with. Servers, in turn, get some work done and respond. In this naïve universe, there is little need for distributed computing infrastructure. However, we can't use this model to build highly scalable distributed systems.

Take email as an example. When someone@company.com sends an email message to myfriend@london.co.uk, it's not the case that their email client locates the mail server london.co.uk and sends the message to it. Instead, the client sends the message to its email server at company.com. Based on the priority of the message and how busy the mail server is, the message will leave either by itself or in a batch of other messages. (Messages are often batched to improve performance.) The message will probably make a few hops through different nodes on the Internet before it gets to the mail server in London.

The lesson from this example is that highly scalable distributed systems (such as email) require flexible buffering of messages and routing based both on message parameters such as origin, destination, and priority, and on the state of the system considering factors such as the availability and load of its nodes as well as network traffic information. Intermediaries hidden from the eyes of the originators and final recipients of messages can perform this work behind the scenes.

Finally, we need intermediaries so that we can provide value-added services in a distributed system. The type of services can vary significantly, and some of them involve the message sender being explicitly aware of the intermediary, unlike our previous examples. Here are a couple of common scenarios:

  • Securing message exchanges, particularly through untrustworthy domains—You could secure SOAP messages by passing them through an intermediary that first encrypts them and then digitally signs them. On the receiving side an intermediary would perform the inverse operations: checking the digital signature and, if it's valid, decrypting the message.

  • Notarization/nonrepudiation—when the sender or receiver (or both) desires a third party to make a record of an interaction, a notarizing intermediary is a likely solution. Instead of sending the message directly to the receiver, the sender sends to the intermediary, who makes a persistent copy of the request and then sends it to the service provider. The response typically comes back via the intermediary as well, and then both parties are usually given a token they can use to reference the transaction record in the future.

  • Providing message tracing facilities—Tracing allows the message recipient to find out the path the message followed, complete with detailed timings of arrivals and departures to and from intermediaries. This information is indispensable for tasks such as measuring quality of service (QoS), auditing systems, and identifying scalability bottlenecks.

Transparent and Explicit Intermediaries

Message senders may or may not be aware of intermediaries in the message path. A transparent intermediary is one the client knows nothing about—the client believes it's sending messages to the actual service endpoint, and the fact that an intermediary is doing work in the middle is incidental. An explicit intermediary, on the other hand, involves specific knowledge on the part of the client—the client knows the message will travel through an intermediary before continuing to its ultimate destination.

The security intermediaries discussed earlier would likely be transparent; the organization providing the service would publish the outward-facing address of the intermediary as the service endpoint. The notarization service described earlier would be an example of an explicit intermediary—the client would know that a notarization step was going on.

Intermediaries in SOAP

SOAP is specifically designed with intermediaries in mind. It has simple yet flexible facilities that address the three key aspects of an intermediary-enabled architecture:

  • How do you pass information to intermediaries?

  • How do you identify who should process what?

  • What happens to information that is processed by intermediaries?

All header elements can optionally have the soapenv:role attribute. The value of this attribute is a URI that identifies who should handle the header entry. Essentially, that URI is the name of the intermediary. This URI might mean a particular node (for instance "the Solaris machine on John's desk"), or it might refer to a class of nodes (as in, "any cache manager along the message path"). (This latter case prompted the name change from actor to role in SOAP 1.2.) Also, a given node can play multiple roles: the Solaris machine on John's desk might also be a cache manager, for instance, so it would recognize either role URI.

The first step any node takes when processing a SOAP message is to collect all the headers that are targeted at the node—this means headers that have a role g attribute matching any of the roles node is playing. It then looks through these nodes for headers marked mustUnderstand and confirms that it recognizes each such header and is able to process it in accordance with the rules associated with that SOAP header. If it finds a mustUnderstand header that it doesn't recognize, it must immediately stop processing.

There are several special values for the role attribute:

  • http://www.w3.org/2003/05/soap-envelope/role/next—Indicates that the header entry's recipient is the next SOAP node that processes the message. This is useful for hop-by-hop processing required, for example, by message tracing.

  • http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver—Refers to the final recipient of the SOAP message. Note that omitting the role attribute or using an empty value ("") also implies that the final recipient of the SOAP message should process the header entry. The final recipient of the SOAP message is the same node that processes the body.

  • http://www.w3.org/2003/05/soap-envelope/role/none—A special role that no SOAP node should ever assume. That means that headers addressed to this role should never be processed; and since no one will ever be in this role, the value of the mustUnderstand attribute won't matter for such headers (remember that the first thing a SOAP node does is pick out the headers it can see by virtue of playing the right role, before looking at mustUnderstand). Also note that the relay attribute (discussed later) never matters on a header addressed to the none role, for the same reason. Even though your SOAP node can't act as the none role, it can still look at the data inside headers marked as none. So, headers marked for the none role can still be used to carry data. (We'll give an example in a bit.)

SOAP 1.1 Difference: actor versus role

In SOAP 1.1, the attribute used to target headers is called actor, not role. Also, SOAP 1.1 only specifies a special next actor URI (http://schemas.xmlsoap.org/soap/actor/next), not an actor for none or ultimateRecipient.

Forwarding and Active Intermediaries

Some intermediaries, like the notarization example discussed earlier, only do processing related to particular headers in the SOAP envelope before forwarding the message to the next node in the message path. In other words, the work of the intermediary is defined by the contents of the incoming messages. These are known as forwarding intermediaries.

Other intermediaries do processing and potentially modify the message in ways not defined by the message contents. For instance, an intermediary at a company boundary to the outside world might add a digital signature header to every outbound message to ensure that receivers can check the integrity of all messages. No explicit markers in the messages are used to trigger this behavior; the node simply does it. This type of intermediary is known as an active intermediary.

Either type of intermediary may do arbitrary work on the message (including the body) based on its internal rules.

Rules for Intermediaries and Headers

By default, all headers targeted at a particular intermediary are removed from the message when it's forwarded on to the next node. This is because the specification tells us that the contract implied by a given header is between the sender of that header and the first node satisfying the role at which it's targeted. Headers that aren't targeted at a particular intermediary should, in general, be forwarded through untouched (see Figure 3.3).

An intermediary removes headers targeted at any role it's playing, regardless of whether they're understood. In Figure 3.4, one header is processed and then removed; another isn't understood, but because it's targeted at our intermediary and not marked mustUnderstand, it's still removed.

Figure 3.3Figure 3.3 Intermediary header removal

Figure 3.4Figure 3.4 Removing optional headers targeted at an intermediary

There are two exceptions to the removal rules. First, the specification for a particular extension may explicitly indicate that an identical copy of a given header from the incoming message is supposed to be placed in the outgoing message. Such headers are known as reinserted, and this has the effect of forwarding them through after processing. An example might be a logging extension targeted at a logManager. Any log manager receiving it along the message path would make a persistent copy of the message for logging purposes and then reinsert the header so that other log managers later in the chain could do the same.

The second exception is when you want to indicate to intermediaries that extensions targeted at them, but not understood, should still be passed through. SOAP 1.2 introduces the relay attribute for this purpose. If the relay attribute is present on a header which is targeted at a given intermediary, and it has the value true, the intermediary should forward the header regardless of whether it understands it. Figure 3.5 shows an unknown header arriving at our notary intermediary. Since all nodes must recognize the next role, the unknown header is targeted at the intermediary. Despite the fact that the intermediary doesn't understand the header, it's forwarded because the relay attribute is true.

Figure 3.5Figure 3.5 Forwarding headers with the relay attribute

  • + Share This
  • 🔖 Save To Your Account