View Javadoc

1   /*
2    * $Id: ProcessController.java,v 1.1 2004/12/15 14:18:10 patforna Exp $
3    *
4    * Copyright (c) 2004 Patric Fornasier, Pawel Kowalski
5    * Berne University of Applied Sciences
6    * School of Engineering and Information Technology
7    * All rights reserved.
8    */
9   package bexee.core;
10  
11  import bexee.model.activity.Activity;
12  import bexee.model.activity.Assign;
13  import bexee.model.activity.Compensate;
14  import bexee.model.activity.Empty;
15  import bexee.model.activity.Flow;
16  import bexee.model.activity.Invoke;
17  import bexee.model.activity.Receive;
18  import bexee.model.activity.Reply;
19  import bexee.model.activity.Sequence;
20  import bexee.model.activity.Switch;
21  import bexee.model.elements.Copy;
22  import bexee.model.elements.Correlation;
23  import bexee.model.elements.CorrelationPattern;
24  import bexee.model.elements.Link;
25  import bexee.model.elements.PartnerLink;
26  import bexee.model.elements.PartnerLinks;
27  import bexee.model.elements.Variable;
28  import bexee.model.elements.Variables;
29  import bexee.model.process.Process;
30  
31  /***
32   * The <code>ProcessController</code> is the core of the engine and contains
33   * the execution logic for every BPEL activity.
34   * <p>
35   * The <code>ProcessController</code> needs to be thread-safe as several
36   * threads may use it simultaneously.
37   * <p>
38   * The current version of bexee doesn't support all possible BPEL activities.
39   * This is the reason, why there is a
40   * <code>process(ProcessInstance, Activity)</code> method, it's a substitute
41   * for all unimplemented activities. When implementing an Activity, the
42   * implementor has to add a method
43   * <code>process(ProcessInstance, NewlyImplActivity)</code> to this interface
44   * and implement it in all implementing classes.
45   * 
46   * @version $Revision: 1.1 $, $Date: 2004/12/15 14:18:10 $
47   * @author Patric Fornasier
48   * @author Pawel Kowalski
49   */
50  public interface ProcessController {
51  
52      /***
53       * Execute the process using the given <code>ProcessInstance</code> and
54       * the <code>BexeeMessage</code>.
55       * 
56       * @param instance
57       *            the <code>ProcessInstance</code>
58       * @param message
59       *            the <code>BexeeMessage</code>
60       */
61      public void processMessage(ProcessInstance instance, BexeeMessage message);
62  
63      /***
64       * Execute the root <code>Process</code> element of the BPEL process.
65       * 
66       * @param process
67       *            root BPEL element
68       * @param instance
69       *            the process instance
70       * @throws Exception
71       */
72      public void process(Process process, ProcessInstance instance)
73              throws Exception;
74  
75      /***
76       * Execute a <code>Receive</code> activity.
77       * 
78       * @param receive
79       * @param instance
80       * @throws Exception
81       */
82      public void process(Receive receive, ProcessInstance instance)
83              throws Exception;
84  
85      /***
86       * Execute an <code>Invoke</code> BPEL activity.
87       * 
88       * @param invoke
89       * @param instance
90       * @throws Exception
91       */
92      public void process(Invoke invoke, ProcessInstance instance)
93              throws Exception;
94  
95      /***
96       * Execute a <code>Reply</code> activity.
97       * 
98       * @param reply
99       * @param instance
100      * @throws Exception
101      */
102     public void process(Reply reply, ProcessInstance instance) throws Exception;
103 
104     /***
105      * Execute a <code>Variable</code> BPEL element.
106      * 
107      * @param variable
108      * @param instance
109      * @throws Exception
110      */
111     public void process(Variable variable, ProcessInstance instance)
112             throws Exception;
113 
114     /***
115      * Execute a <code>Sequence</code> structured activity.
116      * 
117      * @param sequence
118      * @param instance
119      * @throws Exception
120      */
121     public void process(Sequence sequence, ProcessInstance instance)
122             throws Exception;
123 
124     /***
125      * Execute a <code>Switch</code> structured activity.
126      * 
127      * @param bpelSwitch
128      * @param instance
129      * @throws Exception
130      */
131     public void process(Switch bpelSwitch, ProcessInstance instance)
132             throws Exception;
133 
134     /***
135      * Execute a <code>Link</code> BPEL element.
136      * 
137      * @param link
138      * @param instance
139      * @throws Exception
140      */
141     public void process(Link link, ProcessInstance instance) throws Exception;
142 
143     /***
144      * Execute <code>PartnerLinks</code> BPEL element.
145      * 
146      * @param partnerLinks
147      * @param instance
148      * @throws Exception
149      */
150     public void process(PartnerLinks partnerLinks, ProcessInstance instance)
151             throws Exception;
152 
153     /***
154      * Execute a <code>PartnerLink</code> BPEL element.
155      * 
156      * @param partnerLink
157      * @param instance
158      * @throws Exception
159      */
160     public void process(PartnerLink partnerLink, ProcessInstance instance)
161             throws Exception;
162 
163     /***
164      * Execute a <code>Compensate</code> BPEL element.
165      * 
166      * @param compenstate
167      * @param instance
168      * @throws Exception
169      */
170     public void process(Compensate compenstate, ProcessInstance instance)
171             throws Exception;
172 
173     /***
174      * This is the process method for an Activity and is kept here as long as
175      * there exist unimplemented activities.
176      * 
177      * @param assign
178      * @param instance
179      * @throws Exception
180      */
181     public void process(Assign assign, ProcessInstance instance)
182             throws Exception;
183 
184     /***
185      * Execute an <code>Activity</code> activity.
186      * 
187      * @param activity
188      * @param instance
189      * @throws Exception
190      */
191     public void process(Activity activity, ProcessInstance instance)
192             throws Exception;
193 
194     /***
195      * Execute an <code>Empty</code> activity.
196      * 
197      * @param activity
198      * @param instance
199      * @throws Exception
200      */
201 
202     public void process(Empty empty, ProcessInstance instance) throws Exception;
203 
204     /***
205      * Execute a <code>Flow</code> structured activity.
206      * 
207      * @param flow
208      * @param instance
209      * @throws Exception
210      */
211     public void process(Flow flow, ProcessInstance instance) throws Exception;
212 
213     /***
214      * Execute a <code>Variables</code> BPEL element.
215      * 
216      * @param variables
217      * @param instance
218      * @throws Exception
219      */
220     public void process(Variables variables, ProcessInstance instance)
221             throws Exception;
222 
223     /***
224      * Execute a <code>Correlation</code> BPEL element.
225      * 
226      * @param correlation
227      * @param instance
228      * @throws Exception
229      */
230     public void process(Correlation correlation, ProcessInstance instance)
231             throws Exception;
232 
233     /***
234      * Execute a <code>CorrelationPattern</code> BPEL element.
235      * 
236      * @param correlationPattern
237      * @param instance
238      * @throws Exception
239      */
240     public void process(CorrelationPattern correlationPattern,
241             ProcessInstance instance) throws Exception;
242 
243     /***
244      * Execute a <code>Copy</code> BPEL element.
245      * 
246      * @param copy
247      * @param instance
248      */
249     public void process(Copy copy, ProcessInstance instance) throws Exception;
250 
251 }