Software Project / Summer Semester 2004

 
Group 1
Group 2
Liu Guizhu
Li Kun
Li Li
Wang Zheng



Konstantin Geister
Michael Baule
Umashanker Cyopalapillai



INTEGRATING PROLOG IN TRUST NEGOTIATION (TN)

Trust Negotiation. When a transaction between two entities needs to be done, both entities will need some information from the other party. While current approaches relies on the client/server approach where one of the two entities is registered on the other, Automated Trust Negotiation denotes the process where both parties ask and disclose information whenever it is needed according to their own policies.

In order to be able to implement Trust Negotiation an inference engine must be provided. This inference engine is in charge of the evaluation of policies according to peer requests. Current implementation of PeerTrust (TrustNegotiation development at L3S) uses Minerva as a Prolog inference engine. This software project has as a goal the integration of the XSB Prolog inference engine into PeerTrust.

The main goals of this work are:

  • Apply Software Engineer techniques to a real project
  • Develop a project following the software's lifecycle
  • Learn how to document at each stage of the project and why
  • Introduction to one of the most recent topics in security and access control: Trust Negotiation
  • Application of Java and Prolog into a real project

WORKPLAN

Project description
 

E-Learn is a resource provider that offers learning courses to big companies, SMEs and individual clients. E-Learn is the first provider that does not require registration to its clients. It provides a web-based interface where users can browse through the offers. Once a user chooses a course, a java applet starts a Trust Negotiation process between the user's browser and E-Learn Security agent. Once the negotiation successes, the user get access to the course.

Currently, E-Learn's Security agent is implemented in java. Both, the java applet and the security agent, uses Minerva Prolog as inference engine to evaluate the requests. Minerva is commercial product (which requires to pay periodically for a license) and that is why E-Learn wants to integrate an open source (but reliable) Prolog inference engine into its Security Agent software.

E-Learn requires to build a java application which access an inference engine. As we now that InterProlog already provides this java access to XSB, our solution will recommend this approach to E-Learn.

  Useful links:
   
Software Engineering Presentation Topics
 
  • Software Life-Cycle Models
  • Planing Phase
  • Requirements phase
  • Specification phase
  • Object-Oriented Analysis Phase
  • Design Phase
  • Implementation Phase and Implementation and Integration Phase
  • Testing principles
   
1ST STAGE: PROJECT PROPOSAL AND MANAGEMENT PLAN
  Initial Documentation
 
  Requirements
 

E-Learn requires the following two interfaces:

boolean loadFile (String file)

"loadFile" is a method that should load a file from the file system to the inference engine. E-Learn has a knowledge base in several files and it is needed to load them before doing reasoning. This method will return "true" if successful or "false" otherwise.
Arguments:
     String file: name of the file to load
Returns:
     Boolean:
          "true" if successful or
          "false" otherwise

String [] executePredicate (String predicate)

"executePredicate" is a method to send predicates to the inference engine. It sends the query and returns the existing answers in an array. If it returns null it means that the predicate failed.
Arguments:
     String predicate: name of the predicate to evaluate
Returns:
     String []:
          array with the answers or
          "null" if the predicated failed

  Tasks:
 
  • Download and install XSB from http://xsb.sourceforge.net/
  • Download and install InterProlog from http://www.declarativa.com/interprolog/
  • Play and read a bit about how to use the java API
  • Read the requirements specification
  • Write a report (or presentation to sell the project, template here) with a suggested solution for E-Learn based on XSB Prolog Inference Engine and Java Interface (InterProlog)
  Output:
 
  • Proposal Report & Management Plan
   
2ND STAGE: ANALYSIS & SPECIFICATION
  Activities:
 
  • Analyze in detail XSB and InterProlog and write a report with the Analysis of the solution for the project (template here)
  Output:
 
  • Specification report
   
3RD STAGE: DESIGN
  Activities:
 
  • Write a report with the Design to give to the developers and tester team (template here)
  Output:
 
  • Design report
   
4TH STAGE: DEVELOPMENT AND TEST DEFINITION
  Activities:
  This stage has two different tasks that must be performed in parallel:
  • Using the Analysis and Design report, write a "System Test" report with a set of battery tests (template here).
  • Development of the code following the Analysis and Design report (documentation while coding is required)
  Output:
 
  • System Test report
  • Code developed
   
5TH STAGE: TEST
  Activities:
 
  • Use the System Test report to perform the tests on the developed code.
  • If any bug appears, write a report with the bug for the developers team (template here)
  • One of the possible files to load on the inference engine can be downloaded from here. An example predicate to test the execution of a query is: ?- member(X, [1,2,3]).
  Output:
 
  • Set of Bug reports
  • System test report filled with results from the tests
   
6TH STAGE: RELEASE AND DELIVERY
  Activities:
 
  • Write a user manual and create a javadoc document of the code
  • Bring together all the relevant documents and code into a release.
  Output:
 
  • Release
 

Last update on 09-Jun-2006 3:43 PM Home