coursework by stariya


									                           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 interchangeable.

You must 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.

To top