COURSEWORK SPECIFICATION

You are asked to design and implement a simple 'workflow' framework using CORBA technology. In outline, the framework should allow one to submit a 'job' that gets forwarded through a chain of servers, each of which processes the 'job' in some specific way. When the chain has been fully traversed, an appropriate notification and result is sent back to the submitter.

The submitter should initially determine the complete list of servers to be used for a given submission. References to these can be obtained from a name server. The 'job' submission itself should be completely self-contained - i.e. it should contain i) a representation of the 'job' itself, and ii) a list of the servers to be visited. There should be no intermediaries involved in the process of forwarding a job between servers: i.e. each server should pass the job directly to the next (downstream) server.

The 'job' representation could be envisaged as a XML document; but for the purposes of this exercise anything - even just a single integer - could be used. The focus is on the system architecture and the process of passing jobs around rather than on any specific application (although obviously there is a trade-off here in terms of the marks you get!).

Beyond the basic outline specification given above, you might like to consider extensions that increase the power and generality of your framework and/ or show off more advanced features of CORBA or more advanced distributed systems principles. For example, you could consider reliability (what happens if the 'next' server in the chain has crashed, or if a server crashes while a job is being executed?), on demand execution of servers (e.g. using CORBA's object activation features to automatically start a server on its first invocation), parallel execution (i.e. support jobs that can be split into multiple parts that are processed in parallel for a few steps and then rejoined before completion; or conditional branching - i.e. take different paths through the servers depending on the state of the job).

You may implement your solution in any programming language (e.g. Java or C++) and can use any CORBA implementation (e.g. the Java IDL ORB that comes bundled with J2SE -- see here). If you use Java, you MUST use CORBA as opposed to Java-RMI. If you require a more powerful (and complex) ORB than what is available in the standard JDK, there is another Java-based ORB available. JacORB can be downloaded onto your machine and provides a full CORBA specification compatible ORB. Code written in either the JDK ORB or the JacORB "should" be interchangable.

You should prepare a report to accompany your implementation. This should consist of the following sections:

• a detailed specification (this should be based on the above outline but should firm up in any areas you feel need firming up; you are free to do this in any way you choose)
• design (you should justify the design decisions you make and discuss alternatives where appropriate)
• evaluation (evaluate your design and implementation using appropriate criteria which you select yourself - e.g. scalability, reliability, functionality achieved, extensibility, performance, etc.)

The report should be a MAXIMUM of 5 pages in length. You MUST hand in a full program listing with your report. However, you MUST NOT include files that are generated by the IDL compiler. Marks will be approximately allocated according to the following scheme: 50% for meeting the basic spec and producing adequate documentation; the remaining 50% for elements of innovation, creativity and adventure. A demo of your program may be required. Both the report and the programs themselves must be submitted electronically (for plagiarism detection purposes) as well as on paper.