Watch this space: as problems are reported, they will be documented here.

• TSpaces server hangs using FIFO or AndQuery.
  A user reported a problem where the TSpaces server will hang when using waitToTake with FIFO queuing and/or AndQuery. He was able to build a testcase to demonstrate the problem. The problem has been found and fixed and the user has verified the fix in his environment.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• TSpaces server hangs during Deadlock detection.
  The Deadlock detection routine is itself sometimes causing a deadlock. Service Pack 2 is available on Alphaworks to fix this problem. You can also workaround the problem by setting the deadlock detector so that it runs very infrequently (like once an day).
  
  
• XMLQuery can not be used with SubclassableTuple.
  Use of XMLQuery for a SubclassableTuple will cause a ClassCastException.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• Exception on waitToTake with timeout specified.
  It should return "null" when a waitToTake times out.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• File sent to the server using URLCopy are deleted on restart.
  When the server is restarted, file that were submitted to the server using the URLCopy facility are deleted. They should only be deleted if the specified retention period has expired.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• Wrong Tuple is taken under heavy load.
  Under very heavy load of concurrent writes and takes to a single space, a Tuple may be taken that does not match the template.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• XML Query support does not support the FIFO option.
  There are a number of problems with XML Query when the space configuration is specified as FIFO or the system wide FIFO default is chosen.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• Performance problems with XML support.
  There is a serious performance problem when one attempts to write a tuple that contains an XMLField where the XML has many nodes. For example: with 1000 nodes the write may take many minutes.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• Write requests not blocked by scan request under a Transaction.
  If one issues a scan request under a Transaction, all writes to that space should be blocked until the Transaction commit is done. This was not happening when FIFO was specified or IndexQuery was used.
  Service Pack 2 is available on Alphaworks to fix this problem.
  
  
• Duplicate space names.
  Due to a race condition when creating a new space, it is possible to end up with 2 Spaces with identical names. This would only occur when 2 or more threads are started, each of which does a "new TupleSpace(name)" and the space does not yet exist.
  Workaround: This problem can be avoided by issuing an extra "new TupleSpace(name)" before starting the multiple threads. This will ensure that the space is created before the threads obtain their own reference to the space.
  
  

We have provided a cumulative "ServicePack 2" that will fix some of the problems that have been previously discovered and fixed. To install the ServicePack, download: tspaces212sp2.zip from AlphaWorks and unzip it into the same directory where you unziped the original tspaces212.zip file.
The distributed tspaces.bat will automatically cause the fixes to be used. If you are using your own procedures to start TSpaces then update the classpath for your server so that ./lib/tspaces_fixes.jar is the first entry and restart the server. If you do this correctly, the informational message displayed by the server at startup will indicate that it is running
"Version = 2.1.2 ServicePack 2".

Fixes included in Service Pack 2

• TSpaces server hangs using FIFO or AndQuery.
  
• TSpaces server hangs during Deadlock detection.
  
• XMLQuery can not be used with SubclassableTuple.
  
• Exception on waitToTake with timeout specified.
  
• File sent to the server using URLCopy are deleted on restart.
  
• Wrong Tuple is taken under heavy load.
  
• XML Query support does not support the FIFO option.
  
• Performance problems with XML support.
  
• Write requests not blocked by scan request under a Transaction.
  

Valid subcommands are:
        exit      (Abort Server)
        quit      ( quit prompting)
        D         (turns on Debug output)
        D off     (turns off Debug output)
        Dmax      (turns on maximum Debug output)
        q         (Display status)
        shutdown  (Shutdown Server)

kill -QUIT process_id

TupleSpace.setDebug(true);
   ...   your application TSpaces commands
TupleSpace.setDebug(false);

 java -DsocksProxyHost=9.1.40.40 -DsocksProxyPort=1080     MyTSpacesApp

  cd yourdir\tspaces
  set CLASSPATH=.\lib\tspaces.jar;.\lib\util.jar;.\classes
  java com.ibm.tspaces.server.TSServer

  SHELL=c:\windows\command.com /E:8192 /P

The name localhost is the default server name and by convention refers to your local system. TSpaces assumes that you have TCPIP support and can at least initiate a TCPIP connection between 2 local programs.

bin\example Example5 [-h hostname] [-n spacename] userid/password

_ts.write( new Tuple( bigstr ) );

byte[] b = bigstr.getBytes();
_ts.write( new Tuple( b ) );

So even if the TupleSpace object is garbage collected, the connection is there until the client issues cleanup() or terminates.

If you turn on access control checking, then the destroy command requires admin authority.

public boolean call(String eventName,String tsName,int seqNum,
           SuperTuple tuple,boolean isException) {
           if (isException) {
              Exception e = (Exception)tuple.getField(0).getValue();
              if (e.getMessage().equals("Server crashed") ) {
                 ... handle server crash ...
              }
           }
        

TupleSpace ts = new TupleSpace(space,host);
while (true) {
   try {
      while ( ts == null) {
         sleep(5000);
         ts = new TupleSpace(space,host);
      }
      Tuple result = ts.take(template);
   }
   catch(TupleSpaceException e) {
      System.out.println(e);
      TupleSpace.cleanup(ts.getHost(),ts.getPort());
      ts = null;
   }
}

public boolean call( String event,String space,
int seq, SuperTuple tuple,boolean isException)  {

   if ( isException) {
      ts = null;
      return true;
   } else {
      ...

SubTup template = new SubTup();
SubSubTup obj = new SubSubTup();

TupleSpace ts1 = new TupleSpace("space",host);
Transaction tr1 = new Transaction();
tr1.addTupleSpace(t1);
TupleSpace ts2 = new TupleSpace("space",host);
Transaction tr2 = new Transaction();
tr2.addTupleSpace(ts2);

tr1.beginTrans();
tr2.beginTrans();
ts1.write(...
ts2.write(...
tr1.commitTrans();
tr2.commitTrans();

config = new ConfigTuple();
config.setOption(ConfigTuple.FIFO,Boolean.TRUE);
TupleSpace ts = new TupleSpace(tsName,host,config);
String indexName = ConfigTuple.TIMESTAMP_INDEX;

TupleID tid = ts.write(tuple);
tuple = (Tuple)ts.readTupleById(tid);
long lastTimeStamp = test1.getTimeStamp();

Range range = new Range(null,new Long(lastTimeStamp-60*60*1000));
IndexQuery iq = new IndexQuery(indexName,range);
Tuple result = ts.consumingScan(iq);

Tuple template = new Tuple(normal template definition);
Range range = new Range(new Long(lastTimeStamp),null);
IndexQuery iq = new IndexQuery(indexName,range);
MatchQuery mq = new MatchQuery(template);
AndQuery andq = new AndQuery(iq,mq);
Tuple result = ts.scan(andq);

The TSpaces design for Tuple matching is that if you use SubclassableTuple, you don't have to worry about a Tuple inadvertently matching your SublassableTuple just because the structure happens to match. We do have one somewhat exception to this in the DeleteAll command which is unfortunate. At this point, it is probably too late to remove DeleteAll and I hesitate to add a ScanAll command although perhaps that would be reasonable request. But I would not want to add any facility that causes a Tuple template to be a template match for a SubclassableTuple.

However, you do have control over the matches() method in your SubclassableTuple. So if you want your subclassable Tuple to be able to match a Tuple, you can do that. Something like this would work for class MySubclassbleTuple

public boolean matches( SuperTuple t_ ) {
   if (this.numberOfFields() == 0)
      return true;
   return super.matches(t_);
}

MySubclassableTuple all = new MySubclassbleTuple();
Tuple allTuples = ts.scan(all);

        for ( int s = 1; s<999; s++) {
           System.out.println( s );
           byte h[] = new byte[ s*1000 ];
           for( int i=0;i< s*1000; i++) {
              h[i] = 65;
           }
           String key = "hello"+s;
           Tuple t = new Tuple(key, h );
           ts.write( t );
           Tuple template = new Tuple(key,new Field(byte[].class));
           Tuple t2 = ts.read(template);
           System.out.println(t2);
           ts.delete(template);
        }
        

subTuple=new Tuple("SequenceNum", new Integer(sequenceNumber));

Field f1 = new Field("SequenceNum", new  Integer(sequenceNumber));
subTuple = new Tuple(f1);

TupleSpace.setUserName(...);
TupleSpace.setPassword(...);
if (TupleSpace.exists(name,server) {
   ts = new TupleSpace(name,server)
    ...
} else {
   System.out.println("Space does not exist");
}

TupleSpace.appletEnvironment(true);

ts1 = new TupleSpace("space1","billygates.microsoft.com","jorge","pass1");
ts2 = new TupleSpace("space2","BillyGates.microsoft.com","joe","pass2");

Field xmlField = new XMLField(xmlstring);
xmlTuple = new Tuple(xmlField);
write(new Tuple(xmlTuple));

TupleID tid = write(xmlTuple);
write(new Tuple(tid));

Tuple t = new Tuple();
...
Field xmlField = new XMLField(xmlstring);
t.add(xmlField)
write(t);

xql = "invoice//product";
Tuple query = new Tuple(new XMLQuery(xql));
int seq  = ts.eventRegister(TupleSpace.WRITE,query,this);