DISCIPLE Advanced Communication System (ACT)

Developed by Cristian Francu and Ivan Marsic

- How to Get It
- Example Applications
- CORBA 2.x Compliance
- IIOP parser (java sources)
- IIOP engine (parser + rules) (java sources)
- Documentation

The Advanced Communication System (ACT) is a communication toolkit which can be used as a complete communication system. It can be used for implementing a class of communication systems, such as CORBA, or RPC. ACT consists of a CORE part, which must be included, and other components that add extra functionallity, which may or may not be used. It is currently implemented in Java.

The idea behind ACT is that communication systems have a lot of similar functionallity. For example, they use protocols for communication, data marshaling formats, multi-threading policies, etc. Therefore, ACT tries to simplify the construction of a new communication system by providing a frame were only the modules that personalize the system have to be plugged in.

ACT comes toghether with ACT ORB, a CORBA2.0 compliant ORB. ACT ORB is built using ACT. The package also includes several examples, the most complex one being a chat application.

How to Get It

To download and test the demo and the source code of DISCIPLE ACT follow the steps:

Check that you have JDK 1.1 or higher installed on your system.

After you download and install it, have its path included in the CLASSPATH environment variable.

Unix

Download the archive with the latest version of DISCIPLE ACT and the demos.
Expand the archive using the command:
```
        % unzip act98.zip
```
You should obtain a directory called disciple.

You can compile all files in the disciple/java directory or you can use the precompiled files in the directory disciple/classes/. For rebuilding the project, do the followings:

If you want to rebuild the ACT project, you also need to have Perl installed, in order to generate the makefile file. Go to the directory disciple/build/ and edit the Perl program makeMakefile.pl. Change the first two lines following the instructions given in the comments in that file. Run the program to generate the makefile file.
To build the project, issue the command:
```
        % make
```

Windows 95/NT

Download the archive with the latest version of DISCIPLE ACT and the demo.
Expand the archive using WinZip. You should obtain a directory called disciple.

ACT doesn't currently have an easy way to build the application, but until this facility is added you can use the precompiled files.

After copying the archive and expanding it, the last step is to set the system variables. You should define a variable DISCIPLE_HOME setting it to the directory where DISCIPLE ACT resides, for instance ~/disciple. You can do that the following ways:

With csh or tcsh shell edit the .cshrc file and add the line:
- setenv DISCIPLE_HOME ~/disciple

With bash shell edit the .profile file and add the line:
- export DISCIPLE_HOME=~/disciple

Finally you should add $DISCIPLE_HOME/classes to your CLASSPATH variable. Do that in a similar fashion:

With csh or tcsh shell edit the .cshrc file and add the line:
- setenv CLASSPATH $DISCIPLE_HOME/classes:$CLASSPATH

With bash shell edit the .profile file and add the line:
- CLASSPATH=$DISCIPLE_HOME/classes:$CLASSPATH

Example Applications

Currently there are three example applications built using ACT.

One of them illustrates how to implement a protocol with ACT. A fairly simple protocol named TSTP is implemented toghether with a usage example at the protocol level of ACT in the form of a client and a server applications. Look the TSTP example page for description and how to run it.
The other example is ACT MUD, a mud application built using ACT ORB. ACT MUD gives an example of how to use ACT at the presentation layer. Look the ACT MUD example page for description and how to run it.
Here are the sources of an internet server where people can meet and play reversie. Look the Reversie Internet Server and Client (java sources) for description and how to run it.

CORBA 2.x Compliance

ACT implementation includes a complete CORBA ORB. However, there are still some things left to achieve a complete CORBA 2.x compliance. Here is the 'to do' list:

IDL Compiler
- attributes, enums, unions, exceptions, interface inheritance, safe type casting (_is_a method called by narrow).
- portable stubs and skeletons, according to the extra-specification of CORBA for Java, such that they work with any ORB implementation.
- One way operations.
The ORB
- ORB interface (especially the disconnect method, which requires POA.deactivate_object)
- POA interface (especially deactivate_object)
- Object interface
- DII, DSI, Interface Repository, Implementation Repository.
Services (ACT ORB currently provides the naming service)

Documentation

Cristian Francu and Ivan Marsic, An Advanced Communication Toolkit for Implementing the Broker Pattern, International Conference on Distributed Computing Systems (ICDCS), May 1999 (145KB, gzipped postscript file).
Short Slide Show - document containing a 15 minutes presentation of ACT (Microsoft Power Point document) at CAIP Annual Review 1997.
Slide Show - document containing a 75 minutes presentation of ACT (Microsoft Power Point document).