TuCSoN

Tuple Centres Spread over the Network
(description)

TuCSoN (Tuple Centres Spread over the Network) is a Java library providing coordination as a service to Java and tuProlog agents. TuCSoN is a model for the coordination of distributed processes, as well as autonomous, intelligent & mobile agents. TuCSoN exploits tuple centres as its coordination media, which are tuple spaces enhanced with the notion of behaviour specification, thanks to the ReSpecT language.

The TuCSoN coordination technology implements the TuCSoN model as a Java-based distributed middleware, available under GNU LGPL license via GitHub as a Git repository.

Getting Started

  • download tucson.jar archive from the Releases page on its GitHub repository
  • download the libraries it depends on
  • open a command prompt in the folder where you put the two jars above, then type
    • on Linux & Mac OS
      java -cp tucson.jar:2p.jar alice.tucson.service.TucsonNodeService
    • on Windows
      java -cp tucson.jar;2p.jar alice.tucson.service.TucsonNodeService
  • the TuCSoN ASCII logo should appear on the command prompt, as depicted below
    • TuCSoN-boot.jpeg

Documents

Manuals & Guides

“How-To”s

Downloads

The TuCSoN coordination infrastructure is available as an Open Source project on Bitbucket under the LGPL license.

Git QuickStart

Git (download from here) is a Distributed Version Control Systems (DVCSs).

Brief description

A Version Control System is a system that records changes to a file or set of files over time so that you can recall specific versions later.
Centralized Version Control Systems (CVCSs) - such as CVS, Subversion, and Perforce - have a single server that contains all the versioned files, and a number of clients that check out files from that central place. For many years, this has been the standard for version control.
In Distributed Version Control Systems (DVCSs) - such as Git, Mercurial, Bazaar or Darcs - clients don’t just check out the latest snapshot of the files: they fully mirror the repository. Thus if any server dies, and these systems were collaborating via it, any of the client repositories can be copied back up to the server to restore it.

Guides

To download a "Quick Start" pdf guide (edited by Stefano Mariani) click here. For a more in-depth guide refer to GitBook, from which most of the material in such pdf guide is taken.

Basic Command line list

As a quick-access reminder, here follows a list of Git most known and used command line "commands" (sorry for the awkward wordplay) along with a brief description (uppercase-initiated strings are variables with their intuitive meaning):

  • git init - to start tracking an existing local project (type in project dir);
  • git clone [Url] - to mirror locally an existing remote Git repository (type in your preferred target dir which will host your local copy of the project);
  • git add [Filepath] - to begin tracking a new file (works with dirs recursively);
  • git commit -a -m "[Message]" - to register the current state of your project into Git repository;
  • git rm --cached [Filepath] - to stop tracking a tracked file without removing it from your hard disk (works with dirs recursively);
  • git status - to know which files are in which state (committed, staged, untracked basically);
  • git log - to know the repository history (lists all of your previous commits);
  • git branch - to list existing branches;
  • git checkout -b [Branchname] - to create a new branch and suddenly switch to it (create a local copy of your working project and start working on it);
  • git merge [Branchfrom] -m "[Message]" - to merge an existing branch into your current working branch;
  • git tag -a [Tagname] -m "[Message]" - to create a named release of your current working project (a "tag", tipically a non-modifiable snapshot of your current branch);
  • git remote add [Alias] [Url] - to create a shortname to use in place of an existing remote repository complete url (it does not pull dow anything);
  • git pull [Remotealias] - to download all changes made in the target remote repository into your local copy of that repo;
  • git push [Remotealias] [Branchname] - to upload the specified branch to the target remote repository (succeed only if nobody has pushed since your last push)
  • git push [Remotealias] --tags - to upload all your local tags to the target remote repository;
  • git checkout -b [Branchname] [Remotealias]/[Remotebranch] - to start tracking an existing remote branch on the specified remote repository, naming it locally as you prefer (needs git fetch origin first);
  • git clone -b [Branchname] [Remotealias] - to clone only a single branch other than the whole remote Git repository.

Advanced Command line list

Some more involved commands, useful in a plethora of situations:

  • git ls-tree -r [Branch] --name-only - to show tracked files
  • git diff --name-status [Branchfrom]..[Branchto] - to have a quick look at the main differences between two live branches of the project;
  • git diff [Branchfrom]:[Filepath] [Branchto]:[Filepath] - to have a complete description of the differences that two branches have w.r.t. the given file;
  • git checkout [Branchfrom] [Filepath] - to "merge" a single file from the given branch into the working one (notice actually it is more likely an overwrite other than a merge, so be careful);
  • git commit --amend -m "[Msg]" - to replace the last commit message with Msg;
  • git checkout -- . - to discard all the staged changes at once;
  • git checkout -b [Branchto] [Tagfrom] - to create a branch out of a tag and suddenly switch to it;
  • git reset --hard [CommitHash] - to revert the file system status to the given commit;
  • git push [RemoteAlias] :[BranchToDelete] - to delete a remote branch.
  • git log [TagFrom]..[TagTo] > changelog.txt - to print out to a text file the commit log between two tags

TuCSoN4JADE

What is TuCSoN4JADE

TuCSoN4JADE (T4J for short) is a Java library enabling JADE agents to exploit TuCSoN coordination services wrapped as an ad-hoc API into a JADE kernel service.

JADE is a FIPA-compliant Java-based agent development framework featuring standard MAS middleware features such as agent mobility, white and yellow pages service, ACL-based message passing, and built-in FIPA protocols. TuCSoN is a Java-based middleware providing software agents with coordination as a service via programmable logic tuple spaces, called tuple centres. By combining TuCSoN and JADE, T4J aims at providing MAS engineers with a full-featured MAS middleware, enabling them to exploit both dimensions of agent-oriented software engineering — individual, through JADE agents; social, via TuCSoN tuple centres — in a complete and well-balanced way.

T4J is available under GNU LGPL license.

Getting Started

  • download t4j.jar archive from the Downloads section on its Bitbucket repository
  • download the libraries it depends on
    • JADE — from its Download page (jade.jar)
    • TuCSoN — from its Downloads section (tucson.jar)
    • tuProlog — from its Downloads section (2p.jar)
  • open a command prompt in the folder where you put all the four jars above, then type
    • on Linux & Mac OS
      java -cp t4j.jar:tucson.jar:2p.jar:jade.jar jade.Boot -gui -services it.unibo.tucson.jade.service.TucsonService
    • on Windows
      java -cp t4j.jar:tucson.jar;2p.jar;jade.jar jade.Boot -gui -services it.unibo.tucson.jade.service.TucsonService
  • JADE GUI should appear as depicted below
    • t4j-running.jpeg

TuCSoN4Jason

What is TuCSoN4Jason

TuCSoN4Jason (T4Jn for short) is a Java library enabling Jason agents to exploit TuCSoN coordination services wrapped as Jason internal actions. Jason is a well-known Java-based implementation of the AgentSpeak(L) language for BDI agents. TuCSoN is Java-based middleware providing software agents with coordination as a service via programmable logic tuple spaces, called tuple centres.

By combining TuCSoN and Jason, T4Jn aims at providing MAS engineers with a full-featured MAS middleware for cognitive agents, enabling them to exploit both dimensions of agent-oriented software engineering — individual, through Jason agents; social, via TuCSoN tuple centres — in a complete and well-balanced way.

T4Jn is available under GNU LGPL license.

Getting Started

  • download t4jn.jar archive from the Downloads section on its Bitbucket repository
  • download the libraries it depends on
    • Jason — from its Download page (jason.jar)
    • TuCSoN — from its Downloads section (tucson.jar)
    • tuProlog — from its Downloads section (2p.jar)
  • open a command prompt in the folder where you put all the four jars above, then type
    • on Linux & Mac OS
      java -cp libs/tucson.jar:libs/2p.jar alice.TuCSoN.service.TucsonNodeService
    • on Windows
      java -cp libs/tucson.jar;libs/2p.jar alice.TuCSoN.service.TucsonNodeService
  • open a new tab/window of the command prompt in the folder where you put all the four jars above, then type
    • on Linux & Mac OS
      java -cp t4jn.jar:../libs/jason.jar:../libs/2p.jar:../libs/tucson.jar jason.infra.centralised.RunCentralisedMAS t4jn_bookTrading.mas2j
    • on Windows
      java -cp t4jn.jar;../libs/jason.jar;../libs/2p.jar;../libs/tucson.jar jason.infra.centralised.RunCentralisedMAS t4jn_bookTrading.mas2j
  • Jason GUI should appear with the t4jn welcome banner, as depicted below
    • t4jn-running.jpeg
      You should see many prints on Jason GUI, tracking what happens in the MAS.
Logo