Patent Grant
8606843
The present invention generally relates to web services and more specifically relates to processing message traffic patterns occurring in business processes.
Web services are used by businesses to interact via distributed environments, such as the Internet or World Wide Web. To ensure that these interactions are accomplished successfully, protocols must be in place for carrying messages to and from participants, and specific business applications must be in place at each participants end. These interactions, by their very nature are message driven. For example, a buyer sends a purchase order to a seller. The seller then checks its inventory to determine if it can provide the ordered items. The seller then sends an acknowledgement back to the buyer with a price. Finally, the buyer then accepts or rejects the sellers offer (and possibly places another order). As evident in this example, each participant's business application reacts to the receipt of messages. Also illustrated in this example is that these types of web service transactions may take place over long periods of time. Further, each participant may conduct activities at its end, such as tracking messages and updating the status of each activity.
In order for businesses to use web services, the web services should be user friendly. That is, complex, intricate programming steps should be transparent to the participant. The participant should be able to generate high level business applications utilizing nomenclature and concepts familiar to the participant and normally used in the specific business. However, this may be difficult in scenarios in which the sequence and/or timing of incoming and outgoing messages are not known prior to receipt and/or transmission.
Convenient, user friendly, techniques for processing specific web service scenarios, which do not require a participant to be intimately familiar with the complex processing steps necessarily to ensure proper execution of the message driven web service is desired.
In an exemplary embodiment of the present invention, processing of specific scenarios encountered in web services, know as convoy scenarios, provides an application designer or programmer of a workflow application with an efficient and relatively simple mechanism for handling convoy scenarios without having to write and/or be knowledgeable of the intricate processing steps needed to ensure proper execution. There are two broad classes of convoy scenarios; parallel convoys and sequential convoys. A parallel convoy scenario expects two or more messages (possibly of different message types) to be received in parallel (possibly simultaneously) while initializing a correlation. A sequential convoy scenario expects two or more messages to be received in (a possibly unspecified) order where the first receive (first in the sense of instruction order) initializes a correlation and the subsequent receives follow the correlation (viz., only receive a message with property values set to match the correlation). Values within specific fields (viz., properties) of the related messages are not known before the first message is received. Therefore receipt of the first message defines the nature of the relationship of the related messages. Succeeding messages in the group may arrive before any further processing or synchronization takes place, and all messages in the group are processed by the same handler.
To process convoy scenarios, a workflow application is statically analyzed to determine if any convoy scenarios exist. If a convoy scenario, or scenarios, exists, it is classified in accordance with one of at least three convoy classes. These classes include parallel, uniform sequential, and non-uniform sequential convoy classes. A runtime environment is generated that handles messages belonging to a convoy class in accordance with the respective convoy class. The runtime environment is generated in accordance with specialized semantics utilized for each convoy class.
The features and advantages of the present invention will be best understood when considering the following description in conjunction with the accompanying drawings, of which:
Processing convoy scenarios as described herein provides an application designer or programmer of a workflow application with an efficient and relatively simple mechanism for handling convoy scenarios without requiring the programmer or application designer to write and/or be knowledgeable of the intricate processing steps needed to handle convoy scenarios. As described in more detail below, a workflow application is generated using declarative statements indicating that incoming messages are related in some manner. Identifiers (e.g., tokens) embedded in declarative statements, such as receive operations, of the workflow application indicate that messages received with the same type of identifier are a member of a particular convoy class. At compile time, the workflow application is statically analyzed to determine if convoy scenarios exist, in part by searching for these identifiers. If it is determined that convoy scenarios exist, the convoy scenarios are classified as belonging to one of several types of convoy classes. The messages of each convoy class are processed in a manner tailored to the specific class. The handling/processing of convoy scenarios is transparent to the workflow application designer/programmer. The techniques described herein are directed to workflow applications and compilers related to the XLANG/s language used to perform web services based business process operations. However, these convoy processing techniques are not limited to implementations in the XLANG/s language. These convoy processing techniques may be applied to any asynchronous transactional messaging language. The XLANG/s language is simply an example of an asynchronous transactional messaging language. To facilitate an understanding of convoy scenarios, a brief introduction to web services and the XLANG/s language are provided below.
Introduction To Web Services
Businesses, today more then ever, are interacting via distributed environments, such as the Internet or World Wide Web. For example, a user may want to know the prices of rental cars for an upcoming trip. The user may request these prices through an intermediate business on the Internet. The intermediate business, upon receiving the user's request, will send requests to a variety of rental car businesses. After responses are received, the intermediate business will then send the results to the user. The user will then reserve a car and pay for the reservation via the intermediate business. Web services are utilized to facilitate these types of interactions. Web services facilitate the exchange of messages between participants in a distributed environment. Web services technology includes, among other things, communication protocols to facilitate communication between different businesses on the network, and description and discovery standards built around these protocols. At each participant's end, messages must be tracked and processed in accordance with each participant's requirements. A language designed to automate business processes based on web services is XLANG/s. XLANG/s facilitates tracking of messages, processing of incoming and outgoing messages, and enforces adherence to protocol standards.
Introduction to XLANG/s
XLANG/s is described in more detail in a document titled “XLANG/S Language Specification”, Version 0.55, Copyright© Microsoft 1999-2000, and a document titled “XLANG Web Services For Business Process Design, Satish Thatte, Copyright Microsoft Corporation 2001, both of which are hereby incorporated by reference in their entirety as if presented herein. XLANG/s is a language that describes the logical sequencing of business processes, as well as the implementation of the business process by using various technology components or services. The XLANG language is expressed in Extensible Markup Language (XML). The XLANG/s Language is a modern, special purpose language used to describe business process and business protocol. It is a declarative language, and as such it defines an explicit instruction set describing and implementing steps in a business process, the relationship between those steps, their semantics, and interactions. Because of its declarative nature and specific semantics, the resulting executable code is deterministic; that is, the behavior of the running business process is well defined by the semantics of the collection of XLANG/s instructions. The definitions of these business processes in executable form are called orchestrations.
XLANG/s is compatible with many internet standards. XLANG/s is designed to use XML, XSD (XML Schema Definition), XSLT (XSL Transformations), XPATH (XML Path Language), and WSDL (Web Services Description Language) as supported standards and has embedded support for working with .NET based objects and messages. WSDL is described in a document titled “Web Services Description Language (WSDL) 1.1”, W3 C Note January 2001, by Microsoft and IBM Research, Copyright® 2000 Ariba, International Business Machines Corporation, Microsoft, which is hereby incorporated by reference in its entirety as if presented herein. The XLANG/s language is syntactically similar to C#, thus a C# specification may be referenced as an aid to understanding the exact syntax. The semantics embodied in XLANG/s are a reflection of those defined in a document titled “Business Process Execution Language for Web Services”, Version 1.1, dated Mar. 31, 2003, published by Microsoft, IBM, and BEA for the definition of Business Process semantics, which is hereby incorporated by reference in its entirety as if presented herein. The Business Process Execution Language for Web Services specification is commonly referred to as the BPEL4WS specification. The use of XLANG/s is most advantageous when applied to a business process.
The XLANG/s language defines a rich set of high-level constructs used to define business processes. XLANG/s also supports low-level data types such as string and int for example. High-level data-types are also defined such as messages, ports (locations to which messages are sent and received), correlations, and service links. These data-types are used to rigorously define the semantics associated with the business process. These data-types are complemented by process control statements such as ‘if/else if/else’, ‘while’, and ‘scope’ (including transactional scopes, for both long-running and atomic transactions).
A XLANG/s service communicates with the outside world by sending and/or receiving messages. The message type is the structural definition of such a communication entity. Messages are acted upon by operations (e.g., receive, response). An operation may be a single asynchronous message, or a request/response pair of messages. Operations may be either incoming or outgoing. For example, a seller may offer a service/product that begins an interaction by accepting a purchase order (from a potential buyer) via an input message. The seller may then return an acknowledgement to the buyer if the order can be fulfilled. The seller may send additional messages to the buyer (e.g., shipping notices, invoices). Typically, these input and output operations occur in accordance with a defined sequence, referred to as a service process. The seller's service remembers the state of each purchase order interaction separately from other similar interactions. This is particularly advantageous in situations in which the buyer may be conducting many simultaneous purchase processes with the same seller. Also, each instance of a service process may perform activities in the background (e.g., update inventory, update account balance) without the stimulus of an input operation.
A service process may represent an interaction utilizing several operations. As such the interaction has a well-defined beginning and end. This interaction is referred to as an instance of the service. An instance can be started in either of two ways. A service can be explicitly instantiated using some implementation-specific functionality or a service can be implicitly instantiated with an operation in its behavior that is meant to be an instantiation operation. A service instance terminates when the process that defines its behavior terminates.
Services are instantiated in order to act in accordance with the history of an extended interaction. Messages sent to such services are delivered not only to the correct destination port, but to the correct instance of the service that defines the port. A port is an end point where messages are sent and received by a service. The infrastructure hosting the service supports this routing, thus avoiding burdening every service implementation with the need to implement a custom mechanism for instance routing.
For example, consider a typical supply chain situation in which a buyer sends a purchase order to a seller. Assume the buyer and seller have a stable business relationship and are statically configured to send documents related to the purchasing interaction to the URLs associated with the relevant ports. When the seller returns an acknowledgement for the order, the acknowledgement is routed to the correct service instance at the buyer's end. One way to implement this is to carry an embedded token (e.g., cookie) in the order message that is copied into the acknowledgement for correlation. The token may be in the message envelope in a header or in the business document (purchase order) itself. As described in more detail below, in an exemplary embodiment of the present invention, tokens indicative of convoy classes are utilized. The structure and position of the tokens in each message can be expressed declaratively in the service description. This declarative information allows XLANG/s compliant infrastructure to use tokens to provide instance routing automatically.
During its lifetime, a service instance may typically hold one or more conversations with other service instances representing other participants involved in the interaction. Conversations may use a sophisticated transport infrastructure that correlates the messages involved in a conversation and routes them to the correct service instance. In many cases correlated conversations may involve more than two parties or may use lightweight transport infrastructure with correlation tokens embedded directly in the business documents being exchanged. Correlation patterns can become quite complex. For example, a buyer may start a correlated exchange with a seller by sending a purchase order (PO) and using a PO number embedded in the PO document as the correlation token. The PO number is used in the PO acknowledgement by the seller. The seller may later send an invoice that carries both the PO number, to correlate it with the PO, and also an invoice number so that future payment related messages that need carry only the invoice number as the correlation token. The invoice message thus carries two separate correlation tokens and participates in two overlapping correlated exchanges.
XLANG/s addresses correlation scenarios by providing a very general mechanism to specify correlated groups of operations within a service instance. A set of correlation tokens can be defined as a set of properties shared by all messages in the correlated group. Such a set of properties is called a correlation set. The set of operations (in a single service) that is correlated via a correlation set is called a correlation group. A given operation may participate in multiple correlation groups. In an instance of a correlation group, the actual values of the properties in the associated correlation set must be identical for all the actual messages in all the operations involved in the instance. A particular operation may refer to one or more correlation sets. The structure and position of the correlation tokens in each message can be expressed declaratively in the service description (viz., source code). The declarative information allows XLANG/s compliant infrastructure to use correlation tokens to provide instance routing automatically. In an action, when a reference is made to an operation that carries correlation information, the action indicates this by supplying a correlation set reference (viz., correlation sets are used declaratively).
Convoy Scenarios
In an exemplary embodiment of the present invention, advanced workflow programming environments (e.g., such as those implemented in XLANG/s) provide comprehensive and powerful facilities to correlate incoming messages to workflow instances. Certain patterns of use of these correlation facilities are known as “convoy” patterns. From a web services participant's viewpoint, convoy patterns appear to be treated as if received in a single threaded (a.k.a. convoy) fashion in order to achieve correct execution. A convoy scenario is defined by a correlation set initialized on a receive operation which is input to a subsequent receive operation. The compiler detects convoy scenarios by analyzing the control and dataflow of an XLANG/s program. For example, a message may contain a field, or set of fields, in which values identify the message as a member of a group of related messages. These fields may be indicative of, for example, a unique purchase order number, or a social security number. A convoy scenario is one in which the values of the information in these fields is not known before the arrival of the first message. Thus, the first message “defines” the group. Also, in a convoy scenario, succeeding messages in the group may arrive before any further processing or synchronization takes place. Thirdly, all messages in the group are to be processed by the same handler (e.g., same instance of a process). Three types, or classes, of convoy scenarios are described. One class is referred to as a parallel convoy, a second class is referred to as a sequential uniform convoy class, and the third class is referred to as a non-uniform convoy class.
The incoming messages are accepted in the order received, but are processed in parallel. When messages are processed in parallel, multiple branches (e.g., branches 12, 14, and 16) of a business process are processed concurrently. All branches complete processing before any statements following the parallel are executed. In XLANG/s, the parallel statement executes each of the specified tasks concurrently (or at the very minimum in an indeterminate order). The statement is completed when all the tasks of the parallel are completed.
In a parallel convoy scenario, receive statements on at least two different tasks of a parallel are correlated to each other. An example of a parallel convoy scenario in XLANG/s is an activation scenario. In the activation scenario, multiple messages received in the parallel tasks arrive in non-deterministic order. The first received message activates an instance of the XLANG/s process. The other parallel messages are received by the same instance based on their shared correlation values. Thus, actual activation occurs for only one of the set of parallel correlated messages. XLANG/s statements designed to handle parallel convoy scenarios are written in accordance with specific specialized semantics. If one of the tasks of a parallel process has an activatable-receive statement as the first statement, all of the tasks of that parallel process have an activatable receive statement as the first statement. Also, these activatable-receive statements initialize exactly the same correlation sets. More generally, anytime that receive statements appearing on different tasks of a parallel are initializing exactly the same correlation sets, they can be marked as to the convoy class and subject to this semantic specialization. The receive statements share the actual correlation values, and subsequent to the first receive statement initializing the correlation values, all the subsequent receives will receive messages containing exactly the same correlation values. In another semantic specialization, if a particular correlation is initialized on more than one task of a parallel by a receive statement, each of the concerned receive statements initialize exactly the same correlations. Note that even though permitting multiple receive statements on different tasks of a parallel process to initialize a particular correlation set appears to violate the earlier semantic specialization of not allowing a correlation set to be initialized multiple times, this is truly not the case. The latter semantic specialization states that even though the correlation sets appear to be initialized multiple times, the correlation sets are bound to a specific set of values upon the first initialization.
An example of a non-uniform convoy scenario is an inventory order schedule that places an order for a widget and receives a notice when the widget has shipped, initializing a correlation representing the order number and then receives an invoice for the widget, which is routed to the correct order number (viz., follows the already initialized order number correlation). Since the messagetypes are different, the widget shipping notice must be received before the invoice. This requires that the service sending the messages actually sends them in the correct order and it requires that message processing does not change that order. To enforce ordered delivery in message processing the OrderedDeliveryAttribute is added to the port declaration. The XLANG/s source code could take the form:
Referring again to
XLANG/s statements designed to handle sequential convoy scenarios, including the uniform sequential convoy class and the non-uniform sequential convoy class, are written in accordance with specific specialized semantics. Two such semantic specializations that apply to both the uniform sequential convoy class and the non-uniform sequential convoy class include: (1) receive operations causing another receive operation to be fully-defined initialize all the correlation sets for which the second receive operation is a follower (e.g., all the non-initialized correlation sets for the second receive operation are initialized by the first receive operation); and (2) the second receive operation occurs on the same port or service-link as the first receive operation. A third semantic specialization that applies to the uniform sequential convoy class is that the second receive operation receives the same message type as that of the first receive operation. A receive operation is fully defined when all of the correlation sets for which the receive operation is a follower have been initialized and the port or service-link has been definitely assigned. A receive operation is not fully defined when all the correlation sets for which the receive activity is a follower have not been initialized or the port or service-link has not been initialized.
For all of the above mentioned receive operations a processor, such as an XLANG/s compiler, generates a runtime subscription which identifies the respective type of convoy correlation set and its associated message properties. Subscriptions associated with a convoy correlation set lookup the respective business process using the correlation values supplied by the message properties and create a new instance of the correlation set if no business process is associated with the respective correlation set. During subscription creation default values may be associated with a particular correlation set in the situation in which no convoy correlation message properties are associated with the messages. This approach is used to route all messages destined to a particular remote queue to the business processes, or service an instance by forwarding the messages in the order received, for example.
The XLANG/s runtime constructs a subscription for each receive statement in an XLANG/s program and enters it into the routing system. The activate subscriptions are created when the program is “enlisted”, that is at a time before the first execution of the program—since the program must have its activation subscriptions created before it can be activated. All instances of the program will make use of these subscriptions. Non-activation subscriptions are specific to an instance and are normally not created until the subscription's dependent correlation sets are initialized during the course of instance execution.
Subscriptions for convoy receives are handled differently. At program enlistment each of the convoy sets is assigned a unique identifier, a convoy set id, and supplied to the routing system as a set of properties. Each program convoy that contains an activation receive has all of its subscriptions (activation and non-activation) created at this time. All these subscriptions are marked with the corresponding ConvoySetID.
If the convoy does not include any activation receives then the subscriptions are generated at instance execution. The receives in each convoy may include a group of correlation sets that are part of the convoy and a group that are not a part. After the correlation sets that are not part of the convoy are initialized, the subscriptions for the convoy are created. All the properties in the initialized correlation sets become the predicates of the subscriptions. Each subscription is marked with the proper ConvoySetID. The subscription for the receive that is initializing the convoy is marked with CanInitializeConvoySet=True. For parallel convoy cases there may be multiple initializing subscriptions, in which case all are so marked.
During instance execution one or more of the correlation sets that define a convoy may go out of scope. When this occurs the XLANG/s runtime deletes the subscriptions and the convoy instance associated with the corresponding convoy id. If the scope is later re-entered the subscriptions are re-created.
A subscription includes a vector of properties specific to the routing system and a set of related predicates. A subscription typically includes the identifier for the owning service, as well as a service instance identifier if the subscription routes to a specific instance of the service. The set of related predicates are evaluated against the properties of a message or set of messages to determine whether or not that subscription has evaluated to true. Subscriptions are used to route messages which start new instances of a service. Subscriptions are also used to correlate messages to an existing instance of a service (e.g., the purchase order scenario). As described herein, a subscription that starts a new instance of a service is known as an activation subscription and a subscription that routes messages to an existing instance is known as an instance subscription. An instance subscription is identified by noting that the service instance ID on the subscription property vector is not null.
Sample XML text for a subscription is provided below.
For correlation sets whose correlation tokens are known at the time of subscription creation, the correlation set comprises a set of predicates. If the predicate evaluates to true, then the message is routed to an existing instance based upon the instance ID of the subscription property vector. In order to support convoys, the underlying routing subsystem supports correlation sets whose values are known when the subscription is created, and also supports incomplete correlation sets wherein the values will be filled in when the first message is routed (to one of the convoy receives). These incomplete correlation sets, referred to as convoy sets, are preferably shared across subscriptions so that one subscription can initialize a convoy set which other subscriptions subsequently use. In one embodiment, to support this type of sharing, a convoy set is considered to be a separate, yet related, entity from the subscription.
Sample XML text of a convoy set is provided below.
A convoy set comprises an identifier and a set of property names without values. The vector<convoy set id, convoy set property value1, convoy set property value2, . . . , convoy set property valueN, service instance id> is referred to as an instance of the convoy set. This vector is initialized whenever a message is routed to a subscription which is associated with a convoy set, but the message property values associated with the convoy set properties do not correspond to any existing convoy set instance. When this occurs, a new instance of the convoy set is created and any other subscriptions which are associated with this convoy set will have access to it. The combination of convoy set id and convoy set property values making up the convoy set instance are unique. This constraint can be imposed by using any type of locking system before adding the new convoy set instance. In one embodiment, database unique constraints are used on this combination, however other locking enforcements are appropriate. For subscriptions not containing a service instance id, the convoy set instance simply generates a new id.
Sample XML text of a convoy set instance and convoy set id is provided below.
Note that the above XML text compares convoy set properties to determine if they are equal. It is to be understood that other comparison operators may be utilized.
Sequential convoys are distinguished from parallel convoys. A mechanism is provided to allow subscription creators to specify whether all subscriptions using a specific convoy set can initialize the convoy set instance or whether only one can initialize the convoy set instance. In one embodiment, this mechanism comprises a flag on the subscription property vector indicating whether or not the convoy set can be initialized by this subscription.
Sample XML text illustrating this identification flag is provided below.
For a parallel convoy, each subscription is linked to the same convoy set and all subscriptions are marked as CanInitializeConvoySet=True. This allows any message to start the service instance which would subsequently process all related messages. For a sequential convoy only the first subscription is marked as CanInitializeConvoySet=True. This enforces the ordered delivery of messages based upon the protocol described in the service language, in this case, XLANG/s. From the routing subsystems standpoint, there is no difference in uniform versus non-uniform sequential convoys as the uniformity is simply reflected in the predicates of the subscription.
Returning to step 314, if the convoy set id is not NULL, implying that the subscription is associated with a convoy set, then it is determined if this message has the properties required by the convoy set as defined by the ConvoyPredicates, at step 316. If the message does not have the properties required by the convoy set, it can not fill this subscription and so this subscription is ignored at step 322 and the service instance is not notified. If the message does have the properties required by the convoy set (step 316), a search of the list of existing convoy set instances is then conducted at step 320. The search looks for any existing instances that have the same convoy set id and whose convoy set property values correspond to the values associated with this message. For example, if a convoy set with ID=10 is on PurchaseOrderID and this message has PurchaseOrderID=1274, the process would search for convoysetid=10 and PropertyValue[0]=1274. If the convoy set instance corresponding to the values associated with the message has already been created (step 320), then the convoy set instance id is compared with the subscription service instance id at step 324 and the subscription service instance id is compared to NULL. If the convoy set instance id is the same as the subscription service instance id, or the subscription's service instance id is NULL, then, at step 326, the service instance id is set to be the convoy set instance id for the copy of the subscription property vector to be associated with this message. The subscription is then filled at step 332.
Returning to step 324, if the convoy set instance id is not the same as the subscription service instance id, and the subscription's service instance id is not NULL, then at step 328, an error is returned indicating that non-unique values for the correlation set have been used. Returning to step 320, if the convoy set instance does not exist the system determines whether this subscription is allowed to initialize the convoy set at step 334. If the subscription is not allowed to initialize the convoy then we ignore the subscription at step 336 and do not notify the service instance. If convoy set instance can be initialized (step 334), properties are set based upon whether the convoy is sequential or parallel at step 338. The system uses the property values associated with the message for the convoy set properties and the service instance id of the subscription as the convoy set instance id (if there is not service instance id on the subscription we simply generate a new id for the convoy set instance). At this stage, though, a certain level of locking is implemented to ensure that two users do not create the same convoy set instance. Various mechanisms for accomplishing this are envisioned. For example, in one embodiment, access to the entire list of convoy set instances is protected by a read/write lock so that only one user at a time can create a new convoy set instance. To implement this embodiment, the system would acquire write lock on the convoy set instances list and determine if the new instance exists. If the new instance does not exist, a new instance would be created and the write lock would be released. This level of locking, however, is the least granular and does not allow multiple users to simultaneously create convoy set instances for different convoy sets. Thus, in another embodiment, the lock is implemented using a database level unique constraint on the combination of convoy set instance id and property values. This allows the most granular level of locking possible so that even users trying to create new instances of the same convoy set can do so as long as the values differ from all other users creating new convoy set instances at that moment.
If the creation of the new convoy set instance succeeds (step 340), the subscription is filled at step 342. If the creation of the convoy set instance does not succeed (step 340), for example because another user already created this convoy instance, the process proceeds to step 324. Processing from step 324 is as described above.
In one embodiment, the compiler detects convoy scenarios. When the compiler detects that a correlation set is initialized twice the compiler will issue an error, except if the following conditions hold:
1. Each initialization of the correlation set is in a different task of the same parallel statement.
2. Each initialization of the correlation set is in a receive statement.
3. If one of the initializing receives is activatable, then they all are and every task in the parallel must have an activatable receive initializing the same correlation set.
4. The group of correlation sets both initializing and following, must be the same in every receive.
5. Every initializing receive must be on the same port.
In which case, the compiler has found a parallel convoy.
Whenever the compiler detects that a correlation set is initialized in a receive statement it places that information in a dictionary, so that whenever a receive follows on a correlation set, the compiler looks in the dictionary to see if the correlation set is there indicating that it has been initialized in a receive and is a possible convoy. If there happens to be a send which follows on the same correlation set in between (in the sense of instruction order) the initializing and the following receive, then the convoy is said to be broken and convoy processing does not take place. However, in this case the onus is on the user to have a protocol on the other side of the pipe that sends and receives the messages in the instruction order. E.g.,
If the protocol is in any other order, a model/protocol checking compiler pass will be able to diagnose that. Assuming now that a send does not intervene to break the convoy, then an error of an invalid convoy will be issued unless the following conditions:
1. All correlation set initializations must occur in a single receive, called the initializing receive.
2. The ports must be identical in all receive statements in the convoy.
3. The messagetypes must be identical in all receive statements in the convoy, unless the port is annotated with the OrderedDeliveryAttribute.
4. Every following receive must follow every correlation appearing in the initializing receive, unless the port is annotated with the OrderedDeliveryAttribute.
As described above, a convoy scenario may include a parallel convoy scenario, a sequential convoy scenario, or a combination thereof. At step 44, if it is determined that a convoy scenario, or scenarios, exits, the scenario(s) are classified into one of several convoy classes. As described above, convoy classes include a parallel convoy class, a uniform sequential convoy class, and a non-uniform sequential convoy class. At step 46, an infrastructure compatible with a runtime environment, such as the .NET runtime environment, is generated. The convoy class infrastructure correlates messages with business process instances in accordance with convoy class of the messages.
This runtime environment is generated in accordance with the semantic specializations and rules described above to generate the workflow application. Thus, for messages belonging to the parallel convoy class, if the first statement of a task comprises an activatable-receive statement, then all of the tasks of that parallel process have an activatable receive statement as the first statement, these activatable-receive statements initialize exactly the same correlation sets, and if a particular correlation is initialized on more than one task to a receive statement, each of the concerned receive statements initialize exactly the same correlations. For uniform and non-uniform sequential convoy classes, receive operations causing another receive operation to be fully-defined initialize all the correlation sets for which the second receive operation is a follower, and the second receive operation occurs on the same port and/or service-link as the first receive operation. For uniform sequential convoy classes, the second receive operation receives the same message type as the first receive operation.
Overview of a Suitable Computing System Environment
The method and system for processing convoy scenarios are operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well known computing systems, environments, and/or configurations that may be suitable for use with the method and system for processing convoy scenarios include, but are not limited to, personal computers, server computers, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and the like.
The method and system processing convoy scenarios may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The method and system for processing convoy scenarios may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network or other data transmission medium. In a distributed computing environment, program modules and other data may be located in both local and remote computer storage media including memory storage devices.
With reference to
The computer 110 typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer 110 and includes both volatile and non-volatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can accessed by computer 110. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. It is to be understood that combinations of any of the media are also included within the scope of computer readable media.
The system memory 130 includes computer storage media in the form of volatile and/or non-volatile memory such as ROM 131 and RAM 132. A basic input/output system 133 (BIOS), containing the basic routines that help to transfer information between elements within computer 110, such as during start-up, are typically stored in ROM 131. RAM 132 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 120. By way of example, and not limitation,
The computer 110 may also include other removable/non-removable, volatile/non-volatile computer storage media. By way of example only,
The drives and their associated computer storage media, discussed above and illustrated in
The computer 110 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 180. The remote computer 180 may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer 110, although only a memory storage device 181 has been illustrated in
When used in a LAN networking environment, the computer 110 is connected to the LAN 171 through a network interface or adapter 170. When used in a WAN networking environment, the computer 110 typically includes a modem 172 or other means for establishing communications over the WAN 173, such as the Internet. The modem 172, which may be internal or external, may be connected to the system bus 121 via the user input interface 160, or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 110, or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation,
Various distributed computing frameworks have been and are being developed in light of the convergence of personal computing and the Internet. Individuals and business users alike are provided with a seamlessly interoperable and web-enabled interface for applications and computing devices, making computing activities increasingly web browser or network-oriented.
For example, MICROSOFT®'s .NET platform includes servers, building-block services, such as web-based data storage, and downloadable device software. Generally speaking, the .NET platform provides (1) the ability to make the entire range of computing devices work together and to have user information automatically updated and synchronized on all of them, (2) increased interactive capability for web sites, enabled by greater use of XML rather than HTML, (3) online services that feature customized access and delivery of products and services to the user from a central starting point for the management of various applications, such as e-mail, for example, or software, such as Office .NET, (4) centralized data storage, which will increase efficiency and ease of access to information, as well as synchronization of information among users and devices, (5) the ability to integrate various communications media, such as e-mail, faxes, and telephones, (6) for developers, the ability to create reusable modules, thereby increasing productivity and reducing the number of programming errors, and (7) many other cross-platform integration features as well.
While exemplary embodiments herein are described in connection with software residing on a computing device, one or more portions of the method and system for processing convoy scenarios may also be implemented via an operating system, application program interface (API), or a “middle man” object between a coprocessor and requesting object, such that services may be performed by, supported in, or accessed via all of .NET's languages and services, and in other distributed computing frameworks as well.
A method for processing convoy scenarios as described herein may be embodied in the form of computer-implemented processes and system for practicing those processes. A method processing convoy scenarios as described herein may also be embodied in the form of computer program code embodied in tangible media, such as floppy diskettes, read only memories (ROMs), CD-ROMs, hard drives, high density disk, or any other computer-readable storage medium, wherein, when the computer program code is loaded into and executed by a computer, the computer becomes a system for practicing the invention. The method for processing convoy scenarios as described herein may also be embodied in the form of computer program code, for example, whether stored in a storage medium, loaded into and/or executed by a computer, or transmitted over some transmission medium, such as over the electrical wiring or cabling, through fiber optics, or via electromagnetic radiation, wherein, when the computer program code is loaded into and executed by a computer, the computer becomes a system for practicing the invention. When implemented on a general-purpose processor, the computer program code segments configure the processor to create specific logic circuits.
The various techniques described herein may be implemented in connection with hardware or software or, where appropriate, with a combination of both. Thus, the methods and apparatus of the present invention, or certain aspects or portions thereof, may take the form of program code (i.e., instructions) embodied in tangible media, such as floppy diskettes, CD-ROMs, hard drives, or any other machine-readable storage medium, wherein, when the program code is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the invention. In the case of program code execution on programmable computers, the computing device will generally include a processor, a storage medium readable by the processor (including volatile and non-volatile memory and/or storage elements), at least one input device, and at least one output device. One or more programs that may utilize the signal processing services of the present invention, e.g., through the use of a data processing API or the like, are preferably implemented in a high level procedural or object oriented programming language to communicate with a computer. However, the program(s) can be implemented in assembly or machine language, if desired. In any case, the language may be a compiled or interpreted language, and combined with hardware implementations.
The methods and apparatus of the present invention may also be practiced via communications embodied in the form of program code that is transmitted over some transmission medium, such as over electrical wiring or cabling, through fiber optics, or via any other form of transmission, wherein, when the program code is received and loaded into and executed by a machine, such as an EPROM, a gate array, a programmable logic device (PLD), a client computer, a video recorder or the like, or a receiving machine having the signal processing capabilities as described in exemplary embodiments above becomes an apparatus for practicing the invention. When implemented on a general-purpose processor, the program code combines with the processor to provide a unique apparatus that operates to invoke the functionality of the present invention. Additionally, any storage techniques used in connection with the present invention may invariably be a combination of hardware and software.
While embodiments of the present invention has been described in connection with the preferred embodiments of the various figures, it is to be understood that other similar embodiments may be used or modifications and additions may be made to the described embodiment for performing the same function of the present invention without deviating therefrom. Furthermore, it should be emphasized that a variety of computer platforms, including handheld device operating systems and other application specific operating systems are contemplated, especially as the number of wireless networked devices continues to proliferate. Therefore, the present invention should not be limited to any single embodiment, but rather should be construed in breadth and scope in accordance with the appended claims.
This application is a divisional of application Ser. No. 10/452,961 filed Jun. 2, 2003, now U.S. Pat. No. 7,370,333, issued May 6, 2008, the entirety of which is incorporated herein by reference.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5535375 | Eshel et al. | Jul 1996 | A |
| 5630069 | Flores et al. | May 1997 | A |
| 5867824 | Saito et al. | Feb 1999 | A |
| 6529932 | Dadiomov et al. | Mar 2003 | B1 |
| 6571246 | Anderson et al. | May 2003 | B1 |
| 6904431 | Holmgren | Jun 2005 | B2 |
| 7028223 | Kolawa et al. | Apr 2006 | B1 |
| 7055143 | Ringseth et al. | May 2006 | B2 |
| 7110843 | Pagnano et al. | Sep 2006 | B2 |
| 7174338 | Leymann et al. | Feb 2007 | B2 |
| 7188344 | Blue | Mar 2007 | B1 |
| 7340508 | Kasi et al. | Mar 2008 | B1 |
| 20030014733 | Ringseth et al. | Jan 2003 | A1 |
| 20030093468 | Gordon et al. | May 2003 | A1 |
| 20030217094 | Andrews et al. | Nov 2003 | A1 |
| 20030220925 | Lior | Nov 2003 | A1 |
| 20040015564 | Williams | Jan 2004 | A1 |
| 20040139144 | Batra et al. | Jul 2004 | A1 |
| 20040193635 | Hsu et al. | Sep 2004 | A1 |
| Entry |
|---|
| Franciso Curbera, et al. Business Process Executiion Language for Web Services, Version 1.0, Aug. 2002, pp. 30-35. |
| Andrews, T. et al., “Business Process Execution Language for Web Services”, BEA Systems, International Business Machines Corporation, Microsoft Corporation, SAP AG, Siebel Systems, Mar. 31, 2003, http://msdn.microsoft.com, 85 pages. |
| Apshankar, et al., “Web Services Business Strategies and Architectures”, 2002, Chapter 10: Business Process Standards for Web Services, 1-12. |
| Christensen, E. et al., Web Services Description Language (WSDL) 1.1, Ariba, International Business Machines Corporation, Microsoft©, Jan. 2001, http://magnet/wsdl/wsdl—1.1.htm, 45 pages. |
| Curbera, et al., “Web Srevices: Why and How”, 2001, 1-7. |
| Curbera, F. et al., “Unraveling the Web Services Web: An Introduction to SOAP, WSDL, and UDDI”, IEEE Internet Computing, 2002, 6(2), 86-93. |
| Lee, Y.N. et al., “Solving the Convoy Movement Problem Using Branch-and-Bound on a Network of Transputers”, Transputer Applications and Systems, 1994, 786-796. |
| Thatte, S. “XLABG—Web Services for Business Process Design”, Microsoft© Corporation, 2001, 46 pages. |
| XLANG/S-Language Specification, Version 0.55, Microsoft© Corporation, 1999-2002, 146 pages. |
| XML Path Language (XPath) 2.0, W3C®, May 2, 2003, www.w3.org/TR/xpath20, 205 pages. |
| XSL Transformations (XSLT) Version 1.0, W3C®, Nov. 19, 1999, www.w3.org/TR/xslt, 102 pages. |
| Number | Date | Country | |
|---|---|---|---|
| 20080167925 A1 | Jul 2008 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 10452961 | Jun 2003 | US |
| Child | 12054569 | US |
