Skip to main content

Notice: this Wiki will be going read only early in 2024 and edits will no longer be possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.

Jump to: navigation, search

Difference between revisions of "ALF/Vocabularies/Event Declaration Schema"

< ALF
(Event Declaration Schema and WSDL)
(Event Declaration Schema and WSDL)
Line 13: Line 13:
 
The basic technique used here is to define schema "restriction base" derived types that allows you to tighten the value range or other restrictions on certain elements in a complex type.  In this way we can declare a type that is an ALFEventType but that only allows an event type of "ThingCreated" and an object type of either "Thing1" or "Thing2" for example.
 
The basic technique used here is to define schema "restriction base" derived types that allows you to tighten the value range or other restrictions on certain elements in a complex type.  In this way we can declare a type that is an ALFEventType but that only allows an event type of "ThingCreated" and an object type of either "Thing1" or "Thing2" for example.
 
   
 
   
The following sample is derived from 1st round simplification base schema/wsdl (version 001). This is described elsewhere and not relavent to this discussion [[see ALFEventBase_001.xsd and ALFEventManager_001.wsdl in the Architecture section]http://wiki.eclipse.org/index.php/ALF/ALF_Schemas#Introduction]
+
The following sample is derived from 1st round simplification base schema/wsdl (version 001). This is described elsewhere and not relavent to this discussion see ALFEventBase_001.xsd and ALFEventManager_001.wsdl in the Architecture section [[ALF_Schemas#Introduction]]
 
   
 
   
 
The following two files are for a fictitious tool that needs to declare events  
 
The following two files are for a fictitious tool that needs to declare events  

Revision as of 16:31, 6 September 2006

Event Declaration Schema and WSDL

There are a number of goals we wish to achieve.

1. A tool needs to define the Details and Extensions that come with particular event types such that we can design a service flow to access the Detail and Extension data in the event

2. We need to be able to enumerate the possible events as explict combinations for inclusion in the event dispatch map.

3. A design tool may wish to enumerate the possible events to allow a user to pick one to design to. For most BPEL tools this probably means picking a WSDL PortType.

Attached are some experimental schemas and WSDL that illustrate how a tool might declare its ALF events.

The basic technique used here is to define schema "restriction base" derived types that allows you to tighten the value range or other restrictions on certain elements in a complex type. In this way we can declare a type that is an ALFEventType but that only allows an event type of "ThingCreated" and an object type of either "Thing1" or "Thing2" for example.

The following sample is derived from 1st round simplification base schema/wsdl (version 001). This is described elsewhere and not relavent to this discussion see ALFEventBase_001.xsd and ALFEventManager_001.wsdl in the Architecture section ALF_Schemas#Introduction

The following two files are for a fictitious tool that needs to declare events

MyALFEvents_001.xsd MyALFEvents_001.wsdl

The xsd is derived from the ALFEventBase_001.xsd and defines derived restricted types. These restricted type also declare the specific Detail and Extension data that accompanies the particular event. A few variant have been defined to illustrate how restrictions can be combined to create a more compact schema when particular values are valid to use interchangeably (eg any one of these object types can come with this event). I think that this combination is actually a bad idea for reasons discussed below.

The WSDL uses the derived types to redeclare the ALFEventManager WSDL in terms of the more restrictive and details tool specific types.

I am not 100% happy with the result since this requires rather more schema slinging than I feel is ideal. There are also some possible runtime problems with the WSDL.


Problems with the WSDL - goal #1 In schema it is not possible to declare an element as having a type that is a union of complex types. "Choice" comes close but it introduces an <element> and is really a choice of elements that may have different types. Consequently, it is not possible to simply re-declare the base event messages and port type using a union type. A solution is to declare new messages and ports, one set for each event. The unfortunate consequence of this that the message "element" of the event message must be named for the derived event. Since the event operation must still be EventNotice we must break the WSDL "Document Literal Wrapped" convention of the operation and the message element having the same name.

The runtime consequences of this depend on what the tool acutally does when it sends its event message to the EventManager.

It could treat its declarations as simply "for information" descriptions and not be bound to the message name. Consequently, at runtime the tool, will always send the ALFEvent message as defined by the ALFEventManager_001.xsd. That is the message will contain a single element called "EventNotice". The content of the message will vary and will be one of the variants described be the tool schema.

Alternatively, it could use its event message definitions literally and send then with the tool defined element name. The operation must always be EventNotice (or EventNoticeWithReply) but the messages would essentially be event dependant since there root element name would change.

Which of these two possibilities we choose probably shouldn't matter to the EventManager so long as it knows to always search below the root element when finding the fields it uses to dispatch on. However, the root element name may matter to the BPEL flow definition. If a flow is designed to expect a particular message it will probably be the case that it has to have the correct name for its root element. This probably means that the literal message definition technique is required. This may have the undesirable effect of forcing a service flow to be product specific when it doesn't otherwise need to be. This issue remains to be resolved. Probably need to do some experiments.

Problems with the valid combinations - goal #2 The technique of defining the set of possibilities via type restrictions is powerful and allows considerable flexibility as far as how valid combinations can be expressed. We can go from full permutation - any event type can have any object type to full declartion of just the valid combinations - eventA and objectA, eventA and objectB etc. The problem is that these combinations are not easily distilled from the schema. It is probably necessary to walk the tree of event type definitions as XML and accumulate the values that are possible for any particular element. Then you would need to discover which values of another element make valid combinations. The information is there but it is not easy to derive.

Problems with enumerating the events - goal #3 While it is probably easy enough to enumerate port types in the WSDL and find those that contain EventNotice (or EventNoticeWithReply) operations there may be difficulties if the events combinations are not fully and individually declared. This can only be determined by walking the schema. Consequently we should probably recommend that a tool not use a combined declaration for EventBase combinations but should explicitly declare the valid combinations as separate types. A problem is there is probably no way to enforce that.

Schema

MyALFEvents_001.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:evt="http://www.eclipse.org/alf/XMLSchema/Events.xsd" xmlns="http://www.eclipse.org/alf/XMLSchema/Events.xsd" targetNamespace="http://www.eclipse.org/alf/XMLSchema/Events.xsd" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:include schemaLocation="ALFEventBase_001.xsd"/>
	<xs:annotation>
		<xs:documentation>
	WARNING: PRELIMINARY VERSION DO NOT USE
    </xs:documentation>
	</xs:annotation>
	<xs:annotation>
		<xs:documentation>
	Copyright Notice
	The material in this document is Copyright (c) Serena Software, Inc. and others, 2005
	Terms and Conditions:
	The Eclipse Foundation makes available all content in this document ("Content").
	Unless otherwise indicated below, the Content is provided to you under the terms
	and conditions of the Eclipse Public License Version 1.0 ("EPL").
	A copy of the EPL is available at http://www.eclipse.org/legal/epl-v10.html.
	For purposes of the EPL, "Program" will mean the Content.
	If you did not receive this Content directly from the Eclipse Foundation, the
	Content is being redistributed by another party ("Redistributor") and different
	terms and conditions may apply to your use of any object code in the Content.
	Check the Redistributor's license that was provided with the Content.
	If you did not receive any such license, contact the Redistributor.
	Unless otherwise indicated below, the terms and conditions of the EPL still apply to the Content.
    </xs:documentation>
	</xs:annotation>
	<!-- Begin BasicEventTypes -->
	<!-- These event declarations restrict the possible values for EventType, Object and Source.
	There are various options for declaring these derivied types depending on the valid combinations of EventType
	and Object values.
	If any EventType value can be combined with any Object value then all possible values can be declared in a single
	type.
	If only one or some EventType values can be combined with one or some Object value the separate types must be declared for the valid combinations
	Parts of Source is generally constant for any particular product. -->
	<!-- MyBasicEvent1Type is restricted to an event with the value "My Product Event Type A", and an object with the type value, "My Product Object Type A" -->
	<xs:complexType name="MyEventBase1Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="EventBaseType">
				<xs:sequence>
					<xs:element name="EventID" type="EventIDType"/>
					<xs:element name="Timestamp" type="TimestampType"/>
					<xs:element name="EventType" type="MyEventType1Type"/>
					<xs:element name="Object" type="MyObjectData1Type"/>
					<xs:element name="Source" type="MySourceType"/>
					<xs:element name="PredecedingEvent" type="EventIDType" nillable="true"/>
					<xs:element name="ApplicationName" type="ApplicationNameType" nillable="true"/>
					<xs:element name="Environment" type="EnvironmentType" nillable="true"/>
					<xs:element name="User" type="UserType"/>
				</xs:sequence>
				<xs:attribute name="alfEventVersion" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyBasicEvent2Type is restricted to an event with the event value "My Product Event Type B".  
	It may contain object with type values of, "My Product Object Type B" or "My Product Object Type C"-->
	<xs:complexType name="MyEventBase2Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="EventBaseType">
				<xs:sequence>
					<xs:element name="EventID" type="EventIDType"/>
					<xs:element name="Timestamp" type="TimestampType"/>
					<xs:element name="EventType" type="MyEventType2Type"/>
					<xs:element name="Object" type="MyObjectData2Type"/>
					<xs:element name="Source" type="MySourceType"/>
					<xs:element name="PredecedingEvent" type="EventIDType" nillable="true"/>
					<xs:element name="ApplicationName" type="ApplicationNameType" nillable="true"/>
					<xs:element name="Environment" type="EnvironmentType" nillable="true"/>
					<xs:element name="User" type="UserType"/>
				</xs:sequence>
				<xs:attribute name="alfEventVersion" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyBasicEvent3Type is restricted to an event with the event value "My Product Event Type C".  
	It may contain object with type values of, "My Product Object Type B",  "My Product Object Type C" or "My Product Object Type D"-->
	<xs:complexType name="MyEventBase3Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="EventBaseType">
				<xs:sequence>
					<xs:element name="EventID" type="EventIDType"/>
					<xs:element name="Timestamp" type="TimestampType"/>
					<xs:element name="EventType" type="MyEventType3Type"/>
					<xs:element name="Object" type="MyObjectData3Type"/>
					<xs:element name="Source" type="MySourceType"/>
					<xs:element name="PredecedingEvent" type="EventIDType" nillable="true"/>
					<xs:element name="ApplicationName" type="ApplicationNameType" nillable="true"/>
					<xs:element name="Environment" type="EnvironmentType" nillable="true"/>
					<xs:element name="User" type="UserType"/>
				</xs:sequence>
				<xs:attribute name="alfEventVersion" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- In order to restrict the EventType, Object and Source values we need to declare custom restricted types.
	Depending how the allowed values for EventType, Object and Source combine we can declare either one type
	that restricts to all possible values or a number of single value types or some combination -->
	<!-- These EventType variants each have a single possible value -->
	<xs:simpleType name="MyEventType1Type">
		<xs:restriction base="EventTypeType">
			<xs:enumeration value="My Product Event Type A"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="MyEventType2Type">
		<xs:restriction base="EventTypeType">
			<xs:enumeration value="My Product Event Type B"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="MyEventType3Type">
		<xs:restriction base="EventTypeType">
			<xs:enumeration value="My Product Event Type C"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- =============  Object that triggered the event  ============= -->
	<!-- MyObjectData1Type is restricted to one possible value -->
	<!--The ObjectData type derivations illustrate how to combine a number of possible values that may be used interchangeably.
	This can be useful shorthand to compact the event definitions by grouping set of values into a single definition.
	The values in a set may overlap with other sets of the same type but care must be taken to ensure ambiguous or duplicate defintions results.
	-->
	<xs:complexType name="MyObjectData1Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="ObjectDataType">
				<xs:sequence>
					<xs:element name="ObjectType" type="MyObjectType1Type"/>
					<xs:element name="ObjectId" type="ObjectIdType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyObjectType1Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:restriction base="ObjectTypeType">
			<xs:enumeration value="My Product Object Type A"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- MyObjectData2Type is restricted to two possible values -->
	<xs:complexType name="MyObjectData2Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="ObjectDataType">
				<xs:sequence>
					<xs:element name="ObjectType" type="MyObjectType2Type"/>
					<xs:element name="ObjectId" type="ObjectIdType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyObjectType2Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:restriction base="ObjectTypeType">
			<xs:enumeration value="My Product Object Type B"/>
			<xs:enumeration value="My Product Object Type C"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- MyObjectData3Type is restricted to three possible values -->
	<xs:complexType name="MyObjectData3Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:complexContent>
			<xs:restriction base="ObjectDataType">
				<xs:sequence>
					<xs:element name="ObjectType" type="MyObjectType3Type"/>
					<xs:element name="ObjectId" type="ObjectIdType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyObjectType3Type">
		<xs:annotation>
			<xs:documentation>
      </xs:documentation>
		</xs:annotation>
		<xs:restriction base="ObjectTypeType">
			<xs:enumeration value="My Product Object Type B"/>
			<xs:enumeration value="My Product Object Type C"/>
			<xs:enumeration value="My Product Object Type D"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- =============  The source (i.e, tool or product) that emitted the event  ============= -->
	<!-- The values for Product and ProductVersion are constant for all events from a particular product installation -
	ProductInstance and ProductCallbackURI are determined at install time an will not have declared restricted values -->
	<xs:complexType name="MySourceType">
		<xs:complexContent>
			<xs:restriction base="SourceType">
				<xs:sequence>
					<xs:element name="Product" type="MyProductType"/>
					<xs:element name="ProductVersion" type="MyProductVersionType"/>
					<xs:element name="ProductInstance" type="ProductInstanceType"/>
					<xs:element name="ProductCallbackURI" type="ProductCallbackURIType" nillable="true" minOccurs="0"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:simpleType name="MyProductType">
		<xs:restriction base="ProductType">
			<xs:enumeration value="My Product Name"/>
		</xs:restriction>
	</xs:simpleType>
	<xs:simpleType name="MyProductVersionType">
		<xs:restriction base="ProductVersionType">
			<xs:enumeration value="My Product Version"/>
		</xs:restriction>
	</xs:simpleType>
	<!-- Each event type or object type could be associated with different event detail data.
	We need to declare the possible EventDetail types-->
	<xs:complexType name="MyEventDetail1Type">
		<xs:complexContent>
			<xs:restriction base="EventDetailType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventDetail2Type">
		<xs:complexContent>
			<xs:restriction base="EventDetailType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventDetail3Type">
		<xs:complexContent>
			<xs:restriction base="EventDetailType">
				<xs:sequence>
					<xs:element name="MyEventDetailDate1" type="xs:string"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventDetail4Type">
		<xs:complexContent>
			<xs:restriction base="EventExtensionType">
				<xs:sequence>
					<xs:choice>
						<xs:element name="MyEventDetail1" type="MyEventDetail1Type"/>
						<xs:element name="MyEventDetail2" type="MyEventDetail2Type"/>
						<xs:element name="MyEventDetail3" type="MyEventDetail3Type"/>
					</xs:choice>
				</xs:sequence>
				<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- Each event type or object type could be associated with different ToolExtension data.
	We need to declare the possible ToolExtension types-->
	<xs:complexType name="MyEventExtension1Type">
		<xs:complexContent>
			<xs:restriction base="EventExtensionType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
				<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyEventExtension2Type">
		<xs:complexContent>
			<xs:restriction base="EventExtensionType">
				<xs:sequence>
					<xs:any/>
				</xs:sequence>
				<xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- End BasicEventTypes -->
	<!--  BEGIN ALFEvent -->
	<!-- We declare all the possible event structures -->
	<!-- MyALFEvent1Type is restricted to an event with the value "My Product Event Type A", and an object with the type value, "My Product Object Type A".
	The event comes with MyEventDetails1Types event details and MyToolExtensionData1Type tool extension data. -->
	<xs:complexType name="MyALFEvent1Type">
		<xs:complexContent>
			<xs:restriction base="ALFEventType">
				<xs:sequence>
					<xs:element name="Base" type="MyEventBase1Type"/>
					<xs:element name="Detail" type="MyEventDetail1Type"/>
					<xs:element name="Extension" type="MyEventExtension1Type"/>
				</xs:sequence>
				<xs:attribute name="version" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyALFEvent2Type is restricted to an event with the value "My Product Event Type B".  
	It may contain object with type values of, "My Product Object Type A" or "My Product Object Type B".
	The event comes with MyEventDetails2Types event details and MyToolExtensionData2Type tool extension data. -->
	<xs:complexType name="MyALFEvent2Type">
		<xs:complexContent>
			<xs:restriction base="ALFEventType">
				<xs:sequence>
					<xs:element name="Base" type="MyEventBase2Type"/>
					<xs:element name="Detail" type="MyEventDetail2Type"/>
					<xs:element name="Extension" type="MyEventExtension2Type"/>
				</xs:sequence>
				<xs:attribute name="version" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- MyALFEvent3Type iis restricted to an event with the event value "My Product Event Type C".  
	It may contain object with type values of, "My Product Object Type B",  "My Product Object Type C" or "My Product Object Type D"
	The event comes with MyEventDetails2Types event details and MyToolExtensionData2Type tool extension data. -->
	<xs:complexType name="MyALFEvent3Type">
		<xs:complexContent>
			<xs:restriction base="ALFEventType">
				<xs:sequence>
					<xs:element name="Base" type="MyEventBase3Type"/>
					<xs:element name="Detail" type="MyEventDetail2Type"/>
					<xs:element name="Extension" type="MyEventExtension2Type"/>
				</xs:sequence>
				<xs:attribute name="version" type="xs:string" use="required"/>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<xs:complexType name="MyALFEvent3ResponseType">
		<xs:complexContent>
			<xs:restriction base="ALFEventResponseType">
				<xs:sequence>
					<xs:element name="Base" type="EventBaseType"/>
				</xs:sequence>
			</xs:restriction>
		</xs:complexContent>
	</xs:complexType>
	<!-- My Event 1 -->
	<xs:element name="MyEventNotice1" type="MyALFEvent1Type"/>
	<!-- My Event 2 -->
	<xs:element name="MyEventNotice2" type="MyALFEvent2Type"/>
	<!-- My EventWithReply 3 -->
	<xs:element name="MyEventNotice3" type="MyALFEvent3Type"/>
	<xs:element name="MyEventNotice3Response" type="MyALFEvent3ResponseType"/>
</xs:schema>

WSDL

MyALFEvents_001.wsdl

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="MyALFEnabledProduct"
   	targetNamespace="http://www.eclipse.org/alf/XMLSchema/Events.wsdl"
    xmlns:tns="http://www.eclipse.org/alf/XMLSchema/Events.wsdl"
   	xmlns:evt="http://www.eclipse.org/alf/XMLSchema/Events.xsd"
    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
    xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    >
  <wsdl:documentation>
	WARNING: PRELIMINARY VERSION DO NOT USE
  
	  Derived from ALFEventManager WSDL
      Copyright Notice
      The material in this document is Copyright (c) Serena Software, Inc. and others, 2005, 2006
      Terms and Conditions:
      The Eclipse Foundation makes available all content in this document ("Content").
      Unless otherwise indicated below, the Content is provided to you under the terms
      and conditions of the Eclipse Public License Version 1.0 ("EPL").
      A copy of the EPL is available at http://www.eclipse.org/legal/epl-v10.html.
      For purposes of the EPL, "Program" will mean the Content.
      If you did not receive this Content directly from the Eclipse Foundation, the
      Content is being redistributed by another party ("Redistributor") and different
      terms and conditions may apply to your use of any object code in the Content.
      Check the Redistributor's license that was provided with the Content.
      If you did not receive any such license, contact the Redistributor.
      Unless otherwise indicated below, the terms and conditions of the EPL still apply to the Content.
  </wsdl:documentation>
    
	<!-- My ALF Enabled Product Event WSDL -->  
	<wsdl:types>
		<xs:schema elementFormDefault="qualified" targetNamespace="http://www.eclipse.org/alf/XMLSchema/Events.xsd"
					  xmlns:evt="http://www.eclipse.org/alf/XMLSchema/Events.xsd"
					  xmlns="http://www.eclipse.org/alf/XMLSchema/Events.xsd">
			<xs:include schemaLocation="MyALFEvents_001.xsd" />
			
		</xs:schema>
	</wsdl:types>
	
	<!-- These Message definitions are the base messages for ALF events.
	The "EventNotice" has the base event types so therefore it is valid for any derived event type to appear in this message
	-->
	<wsdl:message name="EventNotice">
		<wsdl:part name="parameters" element="evt:EventNotice" />
	</wsdl:message>
	
	<wsdl:message name="EventNoticeResponse">
		<wsdl:part name="parameters" element="evt:EventNoticeResponse" />
	</wsdl:message>
	
	<wsdl:message name="EventNoticeWithReply">
		<wsdl:part name="parameters" element="evt:EventNoticeWithReply" />
	</wsdl:message>

	<wsdl:message name="EventNoticeWithReplyResponse">
		<wsdl:part name="parameters" element="evt:EventNoticeWithReplyResponse" />
	</wsdl:message>
	
	<!-- These Messages definitions allow the creation of PortTypes that are specific to the derived Events -->
	<!-- Note that these messages don't conform to the Document Literal Wrapped convention
	since these are really overloads and the element name "EventNotice" has the base type 
	and so is not useful for specifying the derived types.  Consequently the Message element name 
	cannot be the same as the opereration name for these derived types.
	This is probably not important for ALF.
	 -->
	<wsdl:message name="MyEventNotice1">
		<wsdl:part name="parameters" element="evt:MyEventNotice1" />
	</wsdl:message>
	
	<wsdl:message name="MyEventNotice2">
		<wsdl:part name="parameters" element="evt:MyEventNotice2" />
	</wsdl:message>
	
	<wsdl:message name="MyEventNotice3">
		<wsdl:part name="parameters" element="evt:MyEventNotice3" />
	</wsdl:message>

	<wsdl:message name="MyEventNoticeResponse3">
		<wsdl:part name="parameters" element="evt:MyEventNoticeResponse3" />
	</wsdl:message>

	<!-- This is the base Event port defintion for the event manager -->
	<wsdl:portType name="ALFEventManager">
		<wsdl:operation name="EventNotice">
			<wsdl:input message="tns:EventNotice"/>
			<wsdl:output message="tns:EventNoticeResponse"/>
		</wsdl:operation>
		<wsdl:operation name="EventNoticeWithReply">
			<wsdl:input message="tns:EventNotice"/>
			<wsdl:output message="tns:EventNoticeWithRepyResponse"/>
		</wsdl:operation>
	</wsdl:portType>
	
	<!-- This is the base Event port defintion for any ServiceFlow-->
	<wsdl:portType name="ALFServiceFlow">
		<wsdl:operation name="EventNotice">
			<wsdl:input message="tns:EventNotice"/>
		</wsdl:operation>
	</wsdl:portType>
	
	<!-- This is the base Event port defintion for any ServiceFlow with reply-->
	<wsdl:portType name="ALFServiceFlowWithReply">
		<wsdl:operation name="EventNotice">
			<wsdl:input message="tns:EventNotice"/>
			<wsdl:output message="tns:EventNoticeResponse"/>
		</wsdl:operation>
	</wsdl:portType>
	
	<!-- This is the base Event port defintion for a ServiceFlow specifically designed to use the MyEventNotice1 type-->
	<wsdl:portType name="ALFServiceFlowEventNotice1">
		<wsdl:operation name="EventNotice">
			<wsdl:input message="tns:MyEventNotice1"/>
		</wsdl:operation>
	</wsdl:portType>
	
	<!-- This is the base Event port defintion for a ServiceFlow specifically designed to use the MyEventNotice2 type-->
	<wsdl:portType name="ALFServiceFlowEventNotice2">
		<wsdl:operation name="EventNotice">
			<wsdl:input message="tns:MyEventNotice2"/>
		</wsdl:operation>
	</wsdl:portType>
	
	<!-- This is the base Event port defintion for a ServiceFlow specifically designed to use the MyEventNotice3 type-->
	<wsdl:portType name="ALFServiceFlowWithReplyEventNotice3">
		<wsdl:operation name="EventNotice">
			<wsdl:input message="tns:MyEventNotice3"/>
			<wsdl:output message="tns:MyEventNoticeResponse3"/>
		</wsdl:operation>
	</wsdl:portType>
	
	<!-- These are the base Event and Service Flow bindings -->
	<!-- They are orginally declared in the  ALFEventManager WSDL and repeated here for clarity -->
	<!-- This is the base EventManager binding -->
	<wsdl:binding name="ALFEventManagerSOAP" type="tns:ALFEventManager">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
		<wsdl:operation name="EventNotice">
		<soap:operation soapAction="EventNotice"/>
			<wsdl:input>
				<soap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<soap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
		<wsdl:operation name="EventNoticeWithReply">
		<soap:operation soapAction="EventNoticeWithReply"/>
			<wsdl:input>
				<soap:body use="literal"/>
			</wsdl:input>
			<wsdl:output>
				<soap:body use="literal"/>
			</wsdl:output>
		</wsdl:operation>
	</wsdl:binding>
	
	<!-- This is the base ServiceFlow binding -->
	<wsdl:binding name="ALFServiceFlowSOAP" type="tns:ALFServiceFlow">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
		<wsdl:operation name="EventNotice">
		<soap:operation soapAction="EventNotice"/>
			<wsdl:input>
				<soap:body use="literal"/>
			</wsdl:input>
		</wsdl:operation>
	</wsdl:binding>
	
	<!-- This is the base ServiceFlowWithResonse binding -->
	<wsdl:binding name="ALFServiceFlowWithResponseSOAP" type="tns:ALFServiceFlowWithReply">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
		<wsdl:operation name="EventNotice">
			<soap:operation soapAction="EventNotice"/>
				<wsdl:input>
					<soap:body use="literal"/>
				</wsdl:input>
				<wsdl:output>
					<soap:body use="literal"/>
				</wsdl:output>
		</wsdl:operation>
	</wsdl:binding>
	
	<!-- These are the Event and Service Flow bindings for specific events-->
	<wsdl:binding name="ALFServiceFlow1SOAP" type="tns:ALFServiceFlowEventNotice1">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
		<wsdl:operation name="EventNotice">
		<soap:operation soapAction="EventNotice"/>
			<wsdl:input>
				<soap:body use="literal"/>
			</wsdl:input>
		</wsdl:operation>
	</wsdl:binding>
	
	<wsdl:binding name="ALFServiceFlow2SOAP" type="tns:ALFServiceFlowEventNotice2">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
		<wsdl:operation name="EventNotice">
		<soap:operation soapAction="EventNotice"/>
			<wsdl:input>
				<soap:body use="literal"/>
			</wsdl:input>
		</wsdl:operation>
	</wsdl:binding>
	
	<wsdl:binding name="ALFServiceFlowWithReply3SOAP" type="tns:ALFServiceFlowWithReplyEventNotice3">
		<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
		<wsdl:operation name="EventNotice">
			<soap:operation soapAction="EventNotice"/>
				<wsdl:input>
					<soap:body use="literal"/>
				</wsdl:input>
				<wsdl:output>
					<soap:body use="literal"/>
				</wsdl:output>
		</wsdl:operation>
	</wsdl:binding>
	
	<!-- Example service declarations -->
	<wsdl:service name="ALFEventManager">
		<wsdl:port binding="tns:ALFEventManagerSOAP" name="ALFEventManagerSOAP">
			<soap:address location="http://localhost:8080/alfeventmgr/services/ALFEventManager"/>
		</wsdl:port>
	</wsdl:service>

	<wsdl:service name="ALFServiceFlow1">
		<wsdl:port binding="tns:ALFServiceFlow1SOAP" name="ALFServiceFlow1SOAP">
			<soap:address location="http://localhost:8080/BPELengine/services/ALFServiceFlow1"/>
		</wsdl:port>
	</wsdl:service>
	
	<wsdl:service name="ALFServiceFlow2">
		<wsdl:port binding="tns:ALFServiceFlow2SOAP" name="ALFServiceFlow2SOAP">
			<soap:address location="http://localhost:8080/BPELengine/services/ALFServiceFlow2"/>
		</wsdl:port>
	</wsdl:service>
	
	<wsdl:service name="ALFServiceFlowWithReply3">
		<wsdl:port binding="tns:ALFServiceFlowWithReply3SOAP" name="ALFServiceFlowWithReply3SOAP">
			<soap:address location="http://localhost:8080/BPELengine/services/ALFServiceFlowWithReply3"/>
		</wsdl:port>
	</wsdl:service>		
</wsdl:definitions>

Back to the top