Distributed and Client-Server Systems Assignment.

0 Votes

Distributed and Client-Server Systems Assignment.


The first component of the assignment relates to the material on distributed systems development, with particular emphasis on space-based software architectures; the second relates to client-server systems development, with particular emphasis on CORBA-based software architectures.

The first assignment involves the design and development of a distributed application based upon the JavaSpaces software.

A JavaSpace Auction Room

You are required to design and develop a Java application based on the JavaSpaces technology to provide Auction Room functionalities. Note that this specification is deliberately vague to allow you scope to develop the software in different ways. However, the core functionality must include the following requirements:

The ability for anyone in the room to add a new lot for auction. This could simply be a text description of an item for sale or it could possibly allow the attachment of a gif image of the lot. Other information, such as the seller?s details, will also need to be stored with lot?s details.
The ability for anyone in the room to scroll through all available lots in the space and to recall details of any selected lot for analysis. These details will include a list of all public bids for the item. (See below)
The ability for anyone in the room to make either public or private bids against any item. Public bids will be visible to anyone looking at particular lot but private bids can be seen only by the person selling the item or by the person who placed the bid.
The ability for the owner of a lot to withdraw the item from the sale at any time or to accept the current highest bid. In the latter case, the JavaSpace notify function should be used to inform the successful bidder that their offer has been accepted.
The system should be robust and issues such as Transaction Management should be taken into account and included as and where necessary.

The application MUST have a suitable GUI interface although few marks will be awarded to software with flashy UI but little functionality.

You are free to use a GUI builder if you wish. (e.g. NetBeans, JBuilder, etc) but your code MUST work independent of any IDE.

CORBA Based Client-Server System


The use of Police Monitored Security systems is escalating, resulting in the Police being called to suspected break ?ins in increasing numbers. The number of false ?alarms is becoming epidemic, resulting in wasted time and resources. The police are no longer capable of covering unlicensed systems and even licensed systems are becoming stringently regulated. Police are down-grading systems that generate false alarms and are refusing to be called to systems that do not have intrinsic self checking.

One way around the problem is to have a primary monitoring agency that calls the police if an alarm is raised. This is backed (and accepted by the police) by having a criteria that two separate sensors (of different technologies) must signal an alarm within a short space of time to be recognized as a bona ?fide intruder event.

The use of cameras that can be remotely polled for images can be used by third parties as an alternative backup. Should an alarm be signaled, a monitoring station can poll a camera covering the same zone and a quick-peek will confirm an event has occurred. The Quick Peek Monitoring (QPM) Company are trialing their new CamCorba camera. This combined camera, processor and embedded CORBA or can be attached as a standalone entity on any network.

This means that video monitoring could be done automatically, e.g. the quick peek might simply be interrogating a camera to ascertain its alarm status. Additionally the camera might allow the downloading of the current image. Internally the CamCorba works by comparing the current image with an updated reference image, internally comparing and using Image Processing to ascertain any non random changes. Any changes between the two can be registered as confirmation of an event, and an alarm status set, which may subsequently be reported. This can be reset by an administration function (remotely)

The police in turn could use the quick-peek cameras for their own confirmation view (and their own purposes)

It is envisioned that areas of high risk are to have monitoring stations. These Local Monitoring Stations (LMS) receive signals/alarms from a series of sensors and cameras in the locality of the station. These readings are stored as log and should any sensor raise an alarm, this should be confirmed by the LMS using the designated covering camera. Any confirmed alarms should automatically raise an alarm at the Regional Monitoring Centre (RMC) where an operative will inform the police. This system may in future be enhanced by additionally automatically raising an alarm at the local Police Force Headquarters.

The local police will in any case have direct access to the Quick_peek cameras. This facility will not be available to the RMC as a protection against unauthorized voyeurism.

The centralized (by region) RMC system can interrogate the LMSs to ascertain the current status of warnings and retrieve appropriate log details.

The regional system (RMC) will also maintain a database of contact details for residents and commercial properties that wish to be informed when alarms are raised. The public can register their commercial properties that wish to be informed when alarms are raised. The public can register their wish to be informed of alarms via the Regional Server system.

It is entirely possible that residents could be automatically informed via their home computing facilities not just an automatic phone message. It is also entirely possible that authorized property owners may be allowed access to the cameras that are installed or cover aspects of their own properties to enable them to take a quick ?peek from a designated address (for example, a home PC)

A prototyped distributed Client-Server implementation, based around the CORBA architecture, is proposed. It is envisaged that the CamCorba device, Local Monitoring Station, and the Regional Monitoring Centre are to be prototyped, together with simple client applications that can be used to interrogate the servers and demonstrate the cooperation required between server objects. A simple client that enables interrogation of the CamCorba cameras and a simple program taking the role of a sensor that generates real ?time alarms is to be developed. A simple client program that can be used to obtain status information from the Regional Monitoring Centre is to be developed. A simple server that represents a registered users home PC might also be considered.


1). The CamCorba Device

The CamCorba stand alone video surveillance system is to be prototyped as a CORBA server that supports the following functionality at least:

Maintains an alarm status

Can be switched on

Can be switched off

Can be reset

Maintains a current image that can be provided upon request.

The CamCorba will maintain its own values/images that confirm authenticity of alarms. Note, however, that this is beyond the scope of this assignment and may be mocked by a simple client that can be used to switch an alarm status on and off. Images can be mocked as simple time-stamped strings.

A preliminary IDL starting specification might be:

struct Image{

long time;

long date;

string byteArray;


interface CamCorba{

readonly string name;

attribute WarningLevel current;

Image CurrentImage();


2. The Local Monitoring Station

The LMS is to be prototyped as a CORBA server that supports the following functionality at least:

Registers an intruder alarm from a sensor upon request

Maintains a log of sensor alerts

Retrieves the log upon request

Provides the surrent alarm status upon request

Triggers an alarm at a RMC

Maintains its own sensor/camera zone coverage

A preliminary IDL starting specification might be:

stuct Alarm{

long time;

long date;

string sensor;

string zone;


Typedef sequence <Alarm> Log;

Typedef sequence <String> ZoneCoverage;

Interface LMS {

Readonly string name;

Readonly attribute Log theLog;

Void raise_Alarm (in Alarm aReading);

Void add_Camera (in CamCorba aCamera, in ZoneCoverage zones);


3. The Regional Monitoring Centre

The Regional server is to be prototyped as a CORBA server that supports the following functionality at least:

Retrieves a report on current alarms throughout the region upon request.

Allows a member of the public to register for notification in case of alarms.

Handles authenticated alarms by alerting the Police and Registered users.

A preliminary IDL starting specification might be:

Typedef sequence<string> NotificationList;

struct AlarmData{

Alarm aReading;

String aConfirmingCamera;


Interface RMC{

void raiseAlarm (in AlarmData anAlarm);

void registerUser( in string who, in string contact_details);

WarningLevel CurrentAlarms (in string district);


4. The CamCorba Client

The police should be able to interrogate any camera throughout the region.

5. The Sensor Client

The Sensors can be prototyped as a simple application that sends messages to the Local Monitoring Station. This will also help mimic the real time aspects of the sensors.

6. The RMC client

The client should enable a User to register and to inspect Alarms throughout the region

To make these tasks easier, you may make the following assumptions:

Only one alarm can be serviced at a time
The number of Local Monitoring Stations is fixed. Two LMS is a reasonable number for the purpose of checking the full functionality of you QPM simulation.
The number of sensors per LMS can be fixed. One sensor per LMS generating levels under keyboard control is a minimally sensible start.
Days can be treated as simple integer day numbers (starting from Jan 1st), times can be treated as simple integer minutes starting from midnight.
The client program user interfaces need not be very sophisticated
Any ambiguities may be resolved to your own satisfaction as long as they are clearly justified.

The focus of the assignment is to encourage you to construct a software model of the Quick-peek security scenario in which functionality is achieved by using the services provided by different classes of software objects.