--- a/.classpath	Wed Feb 08 18:02:00 2012 +0900
+++ b/.classpath	Wed Feb 08 18:02:40 2012 +0900
@@ -2,6 +2,7 @@
 <classpath>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="lib" path="lib/protobuf-java-2.3.0.jar"/>
+	<classpathentry kind="lib" path="lib/junit.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

--- a/StartFDLindaServ2.py	Wed Feb 08 18:02:00 2012 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-#! /usr/bin/env python
-"""start process
-"""
-import pexpect
-import re
-import time
-import sys
-import os
-
-def main(base_port, ldserv_num):
-
-    if not os.environ.has_key('LDSERV'):
-        ldserv = "java -classpath FedLinda.jar fdl.FDLindaServ"
-    else:
-        ldserv = os.environ['LDSERV']
-
-    for num in range(0,ldserv_num):
-        cmd = "".join([ldserv + ' -p ' + str(base_port+num) + ' &'])
-        os.system(cmd)
-        print 'start :', cmd
-
-
-if __name__ == "__main__":
-
-    if (len(sys.argv) != 3):
-        print 'Usage : %s <base_port> <ldserv_number>' % sys.argv[0]
-        sys.exit(1)
-
-    main(int(sys.argv[1]), int(sys.argv[2]))

--- a/StopProcess.py	Wed Feb 08 18:02:00 2012 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-#! /usr/bin/env python
-"""find and kill processes
-"""
-import pexpect
-import re
-import sys
-import os
-
-def main(proc):
-    child = pexpect.spawn('ps aucxwww')
-    child.setwinsize(100,300)
-    child.expect(pexpect.EOF)
-
-    pslist =  child.before.splitlines()
-    # separate string by space
-    fmt = re.split(' +', pslist[0])
-
-    if fmt[-1] == '':
-        fmt.pop()
-    if fmt[0] == '':
-        fmt.pop(0)
-    lenfmt = len(fmt)
-
-    # indexing, key is format of output of ps command, value is number of list
-    index = dict([(k,v) for (k,v) in zip(fmt, range(0,lenfmt))])
-
-    # find ".*<processname>.*" in 'COMMAND' part
-    pars = re.compile(".*"+proc+".*")
-    
-    for l in pslist[1:]:
-        elm = re.split(' +',l ,lenfmt)
-        cmd = elm[index['COMMAND']]
-        result = pars.match(cmd)
-
-        if (result is not None):
-            os.system('kill -KILL ' + elm[index['PID']])
-            print 'stop', elm[index['PID']], ':', cmd
-
-
-if __name__== "__main__":
-    if (len(sys.argv) != 2):
-        print "Usage : %s <process_name>" % sys.argv[0]
-        sys.exit(1)
-
-    main(sys.argv[1])
-

--- a/build.xml	Wed Feb 08 18:02:00 2012 +0900
+++ b/build.xml	Wed Feb 08 18:02:40 2012 +0900
@@ -18,7 +18,9 @@
   <!-- ****ターゲット**** -->
   <!-- jarファイルの作成 -->
   <target name="jar" depends="compile">
-    <jar jarfile="${jar}" basedir="${classes}"></jar>
+    <jar jarfile="${jar}" basedir="${classes}">
+        <zipgroupfileset dir="lib" includes="*.jar" />
+	</jar>
   </target>
 
 
@@ -27,6 +29,10 @@
     <mkdir dir="${classes}" />
     <javac encoding="UTF-8" srcdir="src" destdir="${classes}" fork="yes">
         <compilerarg value="-J-Dfile.encoding=UTF8"/>
+    	<classpath>
+    		<pathelement path="lib/protobuf-java-2.3.0.jar" />
+    		<pathelement path="lib/junit.jar" />
+    	</classpath>
         <sourcepath>
          <pathelement path="src"/>
         </sourcepath>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/document/License.txt	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,10 @@
+Entire source code 's license is under
+
+    GNU Lesser General Public License v2 (LGPLv2)
+
+    http://www.gnu.org/licenses/lgpl-2.1.html
+
+Shinji KONO
+    kono@ie.u-ryukyu.ac.jp
+    Sun Oct  2 15:28:13 JST 2011
+

Binary file lib/junit.jar has changed

Binary file lib/protobuf-java-2.3.0.jar has changed

--- a/pexpect.py	Wed Feb 08 18:02:00 2012 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1203 +0,0 @@
-"""Pexpect is a Python module for spawning child applications;
-controlling them; and responding to expected patterns in their output.
-Pexpect can be used for automating interactive applications such as
-ssh, ftp, passwd, telnet, etc. It can be used to a automate setup scripts
-for duplicating software package installations on different servers.
-It can be used for automated software testing. Pexpect is in the spirit of
-Don Libes' Expect, but Pexpect is pure Python. Other Expect-like
-modules for Python require TCL and Expect or require C extensions to
-be compiled. Pexpect does not use C, Expect, or TCL extensions. It
-should work on any platform that supports the standard Python pty
-module. The Pexpect interface focuses on ease of use so that simple
-tasks are easy.
-
-There are two main interfaces to Pexpect. You can call the function:
-        pexpect.run()
-to execute a command and return the output.
-Do no use this on interactive commands that expect input.
-This is a handy replacment for os.system().
-The more useful interface is the class:
-        pexpect.spawn()
-This creates a spawn instance. This will start the command that you specify.
-You can then interact with the child command through the spawn instance.
-Most commands, including ssh, cannot tell that they are being run inside
-of a script. This works even for commands that ask for passwords or
-other input outside of the normal stdio streams.
-
-Pexpect is Open Source, Free, and all that good stuff.
-License: Python Software Foundation License
-         http://www.opensource.org/licenses/PythonSoftFoundation.html
-
-Noah Spurrier
-Richard Holden
-Marco Molteni
-Kimberley Burchett 
-Robert Stone
-Mike Snitzer
-Marti Raudsepp
-Matt <matt (*) corvil.com>
-Hartmut Goebel
-Chad Schroeder
-Erick Tryzelaar
-Dave Kirby
-Ids vander Molen
-George Todd
-Noel Taylor
-Nicolas D. Cesar
-(Let me know if I forgot anyone.)
-
-$Revision: 1.1.1.1 $
-$Date: 2006/04/01 06:03:29 $
-"""
-
-try:
-    import os, sys, time
-    import select
-    import string
-    import re
-    import struct
-    import resource
-    import types
-    import pty
-    import tty
-    import termios
-    import fcntl
-    import errno
-    import traceback
-    import signal
-except ImportError, e:
-    raise ImportError (str(e) + """
-A critical module was not found. Probably this operating system does not support it.
-Pexpect is intended for UNIX-like operating systems.""")
-
-__version__ = '2.0'
-__revision__ = '$Revision: 1.1.1.1 $'
-__all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'run', 'which', 'split_command_line',
-    '__version__', '__revision__']
-
-# Exception classes used by this module.
-class ExceptionPexpect(Exception):
-    """Base class for all exceptions raised by this module.
-    """
-    def __init__(self, value):
-        self.value = value
-    def __str__(self):
-        return str(self.value)
-    def get_trace(self):
-        """This returns an abbreviated stack trace with lines that only concern the caller.
-        In other words, the stack trace inside the Pexpect module is not included.
-        """
-        tblist = traceback.extract_tb(sys.exc_info()[2])
-        tblist = filter(self.__filter_not_pexpect, tblist)
-        tblist = traceback.format_list(tblist)
-        return ''.join(tblist)
-    def __filter_not_pexpect(self, trace_list_item):
-        if trace_list_item[0].find('pexpect.py') == -1:
-            return 1
-        else:
-            return 0
-class EOF(ExceptionPexpect):
-    """Raised when EOF is read from a child.
-    """
-class TIMEOUT(ExceptionPexpect):
-    """Raised when a read time exceeds the timeout.
-    """
-##class TIMEOUT_PATTERN(TIMEOUT):
-##    """Raised when the pattern match time exceeds the timeout.
-##    This is different than a read TIMEOUT because the child process may
-##    give output, thus never give a TIMEOUT, but the output
-##    may never match a pattern.
-##    """
-##class MAXBUFFER(ExceptionPexpect):
-##    """Raised when a scan buffer fills before matching an expected pattern."""
-
-def run (command, timeout=-1, withexitstatus=0, events=None, extra_args=None):
-    """This function runs the given command; waits for it to finish;
-    then returns all output as a string. STDERR is included in output.
-    If the full path to the command is not given then the path is searched.
-
-    Note that lines are terminated by CR/LF (\\r\\n) combination
-    even on UNIX-like systems because this is the standard for pseudo ttys.
-    If you set withexitstatus to true, then run will return a tuple of
-    (command_output, exitstatus). If withexitstatus is false then this
-    returns just command_output.
-
-    Examples:
-    Start the apache daemon on the local machine:
-        from pexpect import *
-        run ("/usr/local/apache/bin/apachectl start")
-    Check in a file using SVN:
-        from pexpect import *
-        run ("svn ci -m 'automatic commit' my_file.py")
-    Run a command and capture exit status:
-        from pexpect import *
-        (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)
-
-    Tricky Examples:   
-    The following will run SSH and execute 'ls -l' on the remote machine.
-    The password 'secret' will be sent if the '(?i)password' pattern is ever seen.
-        run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\n'})
-
-    This will start mencoder to rip a video from DVD. This will also display
-    progress ticks every 5 seconds as it runs.
-        from pexpect import *
-        def print_ticks(d):
-            print d['event_count'],
-        run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5)
-
-    The 'events' argument should be a dictionary of patterns and responses.
-    Whenever one of the patterns is seen in the command out
-    run() will send the associated response string. Note that you should
-    put newlines in your string if Enter is necessary.
-    The responses may also contain callback functions.
-    Any callback is function that takes a dictionary as an argument.
-    The dictionary contains all the locals from the run() function, so
-    you can access the child spawn object or any other variable defined
-    in run() (event_count, child, and extra_args are the most useful).
-    A callback may return True to stop the current run process otherwise
-    run() continues until the next event.
-    A callback may also return a string which will be sent to the child.
-    'extra_args' is not used by directly run(). It provides a way to pass data to
-    a callback function through run() through the locals dictionary passed to a callback.
-    """
-    if timeout == -1:
-        child = spawn(command, maxread=2000)
-    else:
-        child = spawn(command, timeout=timeout, maxread=2000)
-    if events is not None:
-        patterns = events.keys()
-        responses = events.values()
-    else:
-        patterns=None # We assume that EOF or TIMEOUT will save us.
-        responses=None
-    child_result_list = []
-    event_count = 0
-    while 1:
-        try:
-            index = child.expect (patterns)
-            if type(child.after) is types.StringType:
-                child_result_list.append(child.before + child.after)
-            else: # child.after may have been a TIMEOUT or EOF, so don't cat those.
-                child_result_list.append(child.before)
-            if type(responses[index]) is types.StringType:
-                child.send(responses[index])
-            elif type(responses[index]) is types.FunctionType:
-                callback_result = responses[index](locals())
-                sys.stdout.flush()
-                if type(callback_result) is types.StringType:
-                    child.send(callback_result)
-                elif callback_result:
-                    break
-            else:
-                raise TypeError ('The callback must be a string or function type.')
-            event_count = event_count + 1
-        except TIMEOUT, e:
-            child_result_list.append(child.before)
-            break
-        except EOF, e:
-            child_result_list.append(child.before)
-            break
-    child_result = ''.join(child_result_list)
-    if withexitstatus:
-        child.close()
-        return (child_result, child.exitstatus)
-    else:
-        return child_result
-
-class spawn:
-    """This is the main class interface for Pexpect.
-    Use this class to start and control child applications.
-    """
-
-    def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None):
-        """This is the constructor. The command parameter may be a string
-        that includes a command and any arguments to the command. For example:
-            p = pexpect.spawn ('/usr/bin/ftp')
-            p = pexpect.spawn ('/usr/bin/ssh user@example.com')
-            p = pexpect.spawn ('ls -latr /tmp')
-        You may also construct it with a list of arguments like so:
-            p = pexpect.spawn ('/usr/bin/ftp', [])
-            p = pexpect.spawn ('/usr/bin/ssh', ['user@example.com'])
-            p = pexpect.spawn ('ls', ['-latr', '/tmp'])
-        After this the child application will be created and
-        will be ready to talk to. For normal use, see expect() and 
-        send() and sendline().
-
-        The maxread attribute sets the read buffer size.
-        This is maximum number of bytes that Pexpect will try to read from a TTY at one time.
-        The default buffer size is 1 (unbuffered). Setting this value higher
-        will help performance in cases where large amounts of output are read back from the child.
-        This feature is useful in conjunction with searchwindowsize.
-        
-        The searchwindowsize attribute sets the how far back in
-        the incomming seach buffer Pexpect will search for pattern matches.
-        Every time Pexpect reads some data from the child it will append the data to
-        the incomming buffer. The default is to search from the beginning of the
-        imcomming buffer each time new data is read from the child.
-        But this is very inefficient if you are running a command that
-        generates a large amount of data where you want to match
-        The searchwindowsize does not effect the size of the incomming data buffer.
-        You will still have access to the full buffer after expect() returns.
-        
-        The logfile member turns on or off logging.
-        All input and output will be copied to the given file object.
-        Set logfile to None to stop logging. This is the default.
-        Set logfile to sys.stdout to echo everything to standard output.
-        The logfile is flushed after each write.
-        Example 1:
-            child = pexpect.spawn('some_command')
-            fout = file('mylog.txt','w')
-            child.logfile = fout
-        Example 2:
-            child = pexpect.spawn('some_command')
-            child.logfile = sys.stdout
-            
-        The delaybeforesend helps overcome weird behavior that many users were experiencing.
-        The typical problem was that a user would expect() a "Password:" prompt and
-        then immediately call sendline() to send the password. The user would then
-        see that their password was echoed back to them. Of course, passwords don't
-        normally echo. The problem is caused by the fact that most applications
-        print out the "Password" prompt and then turn off stdin echo, but if you
-        send your password before the application turned off echo, then you get
-        your password echoed. Normally this wouldn't be a problem when interacting
-        with a human at a real heyboard. If you introduce a slight delay just before 
-        writing then this seems to clear up the problem. This was such a common problem 
-        for many users that I decided that the default pexpect behavior
-        should be to sleep just before writing to the child application.
-        1/10th of a second (100 ms) seems to be enough to clear up the problem.
-        You can set delaybeforesend to 0 to return to the old behavior.
-        
-        Note that spawn is clever about finding commands on your path.
-        It uses the same logic that "which" uses to find executables.
-
-        If you wish to get the exit status of the child you must call
-        the close() method. The exit or signal status of the child will be
-        stored in self.exitstatus or self.signalstatus.
-        If the child exited normally then exitstatus will store the exit return code and
-        signalstatus will be None.
-        If the child was terminated abnormally with a signal then signalstatus will store
-        the signal value and exitstatus will be None.
-        If you need more detail you can also read the self.status member which stores
-        the status returned by os.waitpid. You can interpret this using
-        os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG.
-        """
-        self.STDIN_FILENO = pty.STDIN_FILENO
-        self.STDOUT_FILENO = pty.STDOUT_FILENO
-        self.STDERR_FILENO = pty.STDERR_FILENO
-        self.stdin = sys.stdin
-        self.stdout = sys.stdout
-        self.stderr = sys.stderr
-
-        self.patterns = None
-        self.before = None
-        self.after = None
-        self.match = None
-        self.match_index = None
-        self.terminated = 1
-        self.exitstatus = None
-        self.signalstatus = None
-        self.status = None
-        self.flag_eof = 0
-        self.pid = None
-        self.child_fd = -1 # initially closed
-        self.timeout = timeout
-        self.delimiter = EOF
-        self.logfile = logfile    
-        self.maxread = maxread # Max bytes to read at one time into buffer.
-        self.buffer = '' # This is the read buffer. See maxread.
-        self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched.
-        self.delaybeforesend = 0.1 # Sets sleep time used just before sending data to child.
-        self.softspace = 0 # File-like object.
-        self.name = '<' + repr(self) + '>' # File-like object.
-        self.encoding = None # File-like object.
-        self.closed = 1 # File-like object.
-        
-        if type (args) != type([]):
-            raise TypeError ('The second argument, args, must be a list.')
-
-        if args == []:
-            self.args = split_command_line(command)
-            self.command = self.args[0]
-        else:
-            self.args = args[:] # work with a copy
-            self.args.insert (0, command)
-            self.command = command
-
-        command_with_path = which(self.command)
-        if command_with_path == None:
-            raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command)
-        self.command = command_with_path
-        self.args[0] = self.command
-
-        self.name = '<' + ' '.join (self.args) + '>'
-        self.__spawn()
-
-    def __del__(self):
-        """This makes sure that no system resources are left open.
-        Python only garbage collects Python objects. OS file descriptors
-        are not Python objects, so they must be handled explicitly.
-        If the child file descriptor was opened outside of this class
-        (passed to the constructor) then this does not close it.
-        """
-        if self.closed:
-            return
-        self.close()
-
-    def __str__(self):
-        """This returns the current state of the pexpect object as a string.
-        """
-        s = []
-        s.append(repr(self))
-        s.append('version: ' + __version__ + ' (' + __revision__ + ')')
-        s.append('command: ' + str(self.command))
-        s.append('args: ' + str(self.args))
-        if self.patterns is None:
-            s.append('patterns: None')
-        else:
-            s.append('patterns:')
-            for p in self.patterns:
-                if type(p) is type(re.compile('')):
-                    s.append('    ' + str(p.pattern))
-                else:
-                    s.append('    ' + str(p))
-        s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:])
-        s.append('before (last 100 chars): ' + str(self.before)[-100:])
-        s.append('after: ' + str(self.after))
-        s.append('match: ' + str(self.match))
-        s.append('match_index: ' + str(self.match_index))
-        s.append('exitstatus: ' + str(self.exitstatus))
-        s.append('flag_eof: ' + str(self.flag_eof))
-        s.append('pid: ' + str(self.pid))
-        s.append('child_fd: ' + str(self.child_fd))
-        s.append('timeout: ' + str(self.timeout))
-        s.append('delimiter: ' + str(self.delimiter))
-        s.append('logfile: ' + str(self.logfile))
-        s.append('maxread: ' + str(self.maxread))
-        s.append('searchwindowsize: ' + str(self.searchwindowsize))
-        s.append('delaybeforesend: ' + str(self.delaybeforesend))
-        return '\n'.join(s)
-
-    def __spawn(self):
-        """This starts the given command in a child process.
-        This does all the fork/exec type of stuff for a pty.
-        This is called by __init__. 
-        """
-        # The pid and child_fd of this object get set by this method.
-        # Note that it is difficult for this method to fail.
-        # You cannot detect if the child process cannot start.
-        # So the only way you can tell if the child process started
-        # or not is to try to read from the file descriptor. If you get
-        # EOF immediately then it means that the child is already dead.
-        # That may not necessarily be bad because you may haved spawned a child
-        # that performs some task; creates no stdout output; and then dies.
-
-        assert self.pid == None, 'The pid member should be None.'
-        assert self.command != None, 'The command member should not be None.'
-
-        try:
-            self.pid, self.child_fd = pty.fork()
-        except OSError, e:
-            raise ExceptionPexpect('Pexpect: pty.fork() failed: ' + str(e))
-
-        if self.pid == 0: # Child
-            try: # Some platforms do not like setwinsize (Cygwin).
-                self.child_fd = sys.stdout.fileno() # used by setwinsize()
-                self.setwinsize(24, 80)
-            except:
-                pass
-            # Do not allow child to inherit open file descriptors from parent.
-            max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
-            for i in range (3, max_fd):
-                try:
-                    os.close (i)
-                except OSError:
-                    pass
-
-            # I don't know why this works, but ignoring SIGHUP fixes a
-            # problem when trying to start a Java daemon with sudo
-            # (specifically, Tomcat).
-            signal.signal(signal.SIGHUP, signal.SIG_IGN)
-
-            os.execv(self.command, self.args)
-
-        # Parent
-        self.terminated = 0
-        self.closed = 0
-
-    def fileno (self):   # File-like object.
-        """This returns the file descriptor of the pty for the child.
-        """
-        return self.child_fd
-
-    def close (self, force=0):   # File-like object.
-        """This closes the connection with the child application.
-        Note that calling close() more than once is valid.
-        This emulates standard Python behavior with files.
-        Set force to 1 if you want to make sure that the child is terminated
-        (SIGKILL is sent if the child ignores SIGHUP and SIGINT).
-        """
-        if self.child_fd != -1:
-            self.flush()
-            os.close (self.child_fd)
-            self.child_fd = -1
-            self.closed = 1
-            time.sleep(0.1) # Give kernel time to update process status.
-            if self.isalive():
-                if not self.terminate(force):
-                    raise ExceptionPexpect ('close() could not terminate the child using terminate()')
-
-    def flush (self):   # File-like object.
-        """This does nothing. It is here to support the interface for a File-like object.
-        """
-        pass
-
-    def isatty (self):   # File-like object.
-        """This returns 1 if the file descriptor is open and connected to a tty(-like) device, else 0.
-        """
-        return os.isatty(self.child_fd)
-
-    def setecho (self, on):
-        """This sets the terminal echo mode on or off.
-        Note that anything the child sent before the echo will be lost, so
-        you should be sure that your input buffer is empty before you setecho.
-        For example, the following will work as expected.
-            p = pexpect.spawn('cat')
-            p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
-            p.expect (['1234'])
-            p.expect (['1234'])
-            p.setecho(0) # Turn off tty echo
-            p.sendline ('abcd') # We will set this only once (echoed by cat).
-            p.sendline ('wxyz') # We will set this only once (echoed by cat)
-            p.expect (['abcd'])
-            p.expect (['wxyz'])
-        The following WILL NOT WORK because the lines sent before the setecho
-        will be lost:
-            p = pexpect.spawn('cat')
-            p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
-            p.setecho(0) # Turn off tty echo
-            p.sendline ('abcd') # We will set this only once (echoed by cat).
-            p.sendline ('wxyz') # We will set this only once (echoed by cat)
-            p.expect (['1234'])
-            p.expect (['1234'])
-            p.expect (['abcd'])
-            p.expect (['wxyz'])
-        """
-        self.child_fd
-        new = termios.tcgetattr(self.child_fd)
-        if on:
-            new[3] = new[3] | termios.ECHO
-        else:
-            new[3] = new[3] & ~termios.ECHO
-        # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent
-        # and blocked on some platforms. TCSADRAIN is probably ideal if it worked.
-        termios.tcsetattr(self.child_fd, termios.TCSANOW, new)
-
-    def read_nonblocking (self, size = 1, timeout = -1):
-        """This reads at most size characters from the child application.
-        It includes a timeout. If the read does not complete within the
-        timeout period then a TIMEOUT exception is raised.
-        If the end of file is read then an EOF exception will be raised.
-        If a log file was set using setlog() then all data will
-        also be written to the log file.
-
-        If timeout==None then the read may block indefinitely.
-        If timeout==-1 then the self.timeout value is used.
-        If timeout==0 then the child is polled and 
-            if there was no data immediately ready then this will raise a TIMEOUT exception.
-        
-        The "timeout" refers only to the amount of time to read at least one character.
-        This is not effected by the 'size' parameter, so if you call
-        read_nonblocking(size=100, timeout=30) and only one character is
-        available right away then one character will be returned immediately. 
-        It will not wait for 30 seconds for another 99 characters to come in.
-        
-        This is a wrapper around os.read().
-        It uses select.select() to implement a timeout. 
-        """
-        if self.child_fd == -1:
-            raise ValueError ('I/O operation on closed file in read_nonblocking().')
-
-        if timeout == -1:
-            timeout = self.timeout
-
-        # Note that some systems such as Solaris do not give an EOF when
-        # the child dies. In fact, you can still try to read
-        # from the child_fd -- it will block forever or until TIMEOUT.
-        # For this case, I test isalive() before doing any reading.
-        # If isalive() is false, then I pretend that this is the same as EOF.
-        if not self.isalive():
-            r, w, e = select.select([self.child_fd], [], [], 0) # timeout of 0 means "poll"
-            if not r:
-                self.flag_eof = 1
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.')
-        elif sys.platform.lower().find('irix') >= 0:
-            # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive.
-            # This adds a 2 second delay, but only when the child is terminated
-            r, w, e = select.select([self.child_fd], [], [], 2)
-            if not r and not self.isalive():
-                self.flag_eof = 1
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.')
-            
-        r, w, e = select.select([self.child_fd], [], [], timeout)
-        if not r:
-            if not self.isalive():
-                # Some platforms, such as Irix, will claim that their processes are alive;
-                # then timeout on the select; and then finally admit that they are not alive.
-                self.flag_eof = 1
-                raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.')
-            else:
-                raise TIMEOUT ('Timeout exceeded in read_nonblocking().')
-
-        if self.child_fd in r:
-            try:
-                s = os.read(self.child_fd, size)
-            except OSError, e: # Linux does this
-                self.flag_eof = 1
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.')
-            if s == '': # BSD style
-                self.flag_eof = 1
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.')
-
-            if self.logfile != None:
-                self.logfile.write (s)
-                self.logfile.flush()
-
-            return s
-
-        raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().')
-
-    def read (self, size = -1):   # File-like object.
-        """This reads at most "size" bytes from the file 
-        (less if the read hits EOF before obtaining size bytes). 
-        If the size argument is negative or omitted, 
-        read all data until EOF is reached. 
-        The bytes are returned as a string object. 
-        An empty string is returned when EOF is encountered immediately.
-        """
-        if size == 0:
-            return ''
-        if size < 0:
-            self.expect (self.delimiter) # delimiter default is EOF
-            return self.before
-
-        # I could have done this more directly by not using expect(), but
-        # I deliberately decided to couple read() to expect() so that
-        # I would catch any bugs early and ensure consistant behavior.
-        # It's a little less efficient, but there is less for me to
-        # worry about if I have to later modify read() or expect().
-        # Note, it's OK if size==-1 in the regex. That just means it
-        # will never match anything in which case we stop only on EOF.
-        cre = re.compile('.{%d}' % size, re.DOTALL) 
-        index = self.expect ([cre, self.delimiter]) # delimiter default is EOF
-        if index == 0:
-            return self.after ### self.before should be ''. Should I assert this?
-        return self.before
-        
-    def readline (self, size = -1):    # File-like object.
-        """This reads and returns one entire line. A trailing newline is kept in
-        the string, but may be absent when a file ends with an incomplete line. 
-        Note: This readline() looks for a \\r\\n pair even on UNIX because this is 
-        what the pseudo tty device returns. So contrary to what you may be used to
-        you will receive a newline as \\r\\n.
-        An empty string is returned when EOF is hit immediately.
-        Currently, the size agument is mostly ignored, so this behavior is not
-        standard for a file-like object. If size is 0 then an empty string is returned.
-        """
-        if size == 0:
-            return ''
-        index = self.expect (['\r\n', self.delimiter]) # delimiter default is EOF
-        if index == 0:
-            return self.before + '\r\n'
-        else:
-            return self.before
-
-    def __iter__ (self):    # File-like object.
-        """This is to support interators over a file-like object.
-        """
-        return self
-
-    def next (self):    # File-like object.
-        """This is to support iterators over a file-like object.
-        """
-        result = self.readline()
-        if result == "":
-            raise StopIteration
-        return result
-
-    def readlines (self, sizehint = -1):    # File-like object.
-        """This reads until EOF using readline() and returns a list containing 
-        the lines thus read. The optional "sizehint" argument is ignored.
-        """        
-        lines = []
-        while 1:
-            line = self.readline()
-            if not line:
-                break
-            lines.append(line)
-        return lines
-
-    def write(self, str):   # File-like object.
-        """This is similar to send() except that there is no return value.
-        """
-        self.send (str)
-
-    def writelines (self, sequence):   # File-like object.
-        """This calls write() for each element in the sequence.
-        The sequence can be any iterable object producing strings, 
-        typically a list of strings. This does not add line separators
-        There is no return value.
-        """
-        for str in sequence:
-            self.write (str)
-
-    def send(self, str):
-        """This sends a string to the child process.
-        This returns the number of bytes written.
-        If a log file was set then the data is also written to the log.
-        """
-        time.sleep(self.delaybeforesend)
-        if self.logfile != None:
-            self.logfile.write (str)
-            self.logfile.flush()
-        c = os.write(self.child_fd, str)
-        return c
-
-    def sendline(self, str=''):
-        """This is like send(), but it adds a line feed (os.linesep).
-        This returns the number of bytes written.
-        """
-        n = self.send(str)
-        n = n + self.send (os.linesep)
-        return n
-
-    def sendeof(self):
-        """This sends an EOF to the child.
-        This sends a character which causes the pending parent output
-        buffer to be sent to the waiting child program without
-        waiting for end-of-line. If it is the first character of the
-        line, the read() in the user program returns 0, which
-        signifies end-of-file. This means to work as expected 
-        a sendeof() has to be called at the begining of a line. 
-        This method does not send a newline. It is the responsibility
-        of the caller to ensure the eof is sent at the beginning of a line.
-        """
-        ### Hmmm... how do I send an EOF?
-        ###C  if ((m = write(pty, *buf, p - *buf)) < 0)
-        ###C      return (errno == EWOULDBLOCK) ? n : -1;
-        fd = sys.stdin.fileno()
-        old = termios.tcgetattr(fd) # remember current state
-        new = termios.tcgetattr(fd)
-        new[3] = new[3] | termios.ICANON # ICANON must be set to recognize EOF
-        try: # use try/finally to ensure state gets restored
-            termios.tcsetattr(fd, termios.TCSADRAIN, new)
-            if 'CEOF' in dir(termios):
-                os.write (self.child_fd, '%c' % termios.CEOF)
-            else:
-                os.write (self.child_fd, '%c' % 4) # Silly platform does not define CEOF so assume CTRL-D
-        finally: # restore state
-            termios.tcsetattr(fd, termios.TCSADRAIN, old)
-
-    def eof (self):
-        """This returns 1 if the EOF exception was raised at some point.
-        """
-        return self.flag_eof
-
-    def terminate(self, force=0):
-        """This forces a child process to terminate.
-        It starts nicely with SIGHUP and SIGINT. If "force" is 1 then
-        moves onto SIGKILL.
-        This returns true if the child was terminated.
-        This returns false if the child could not be terminated.
-        """
-        if not self.isalive():
-            return 1
-        self.kill(signal.SIGHUP)
-        time.sleep(0.1)
-        if not self.isalive():
-            return 1
-        self.kill(signal.SIGCONT)
-        time.sleep(0.1)
-        if not self.isalive():
-            return 1
-        self.kill(signal.SIGINT)
-        time.sleep(0.1)
-        if not self.isalive():
-            return 1
-        if force:
-            self.kill(signal.SIGKILL)
-            time.sleep(0.1)
-            if not self.isalive():
-                return 1
-            else:
-                return 0
-        return 0
-        #raise ExceptionPexpect ('terminate() could not terminate child process. Try terminate(force=1)?')
-        
-    def isalive(self):
-        """This tests if the child process is running or not.
-        This is non-blocking. If the child was terminated then this
-        will read the exitstatus or signalstatus of the child.
-        This returns 1 if the child process appears to be running or 0 if not.
-        It can take literally SECONDS for Solaris to return the right status.
-        """
-        if self.terminated:
-            return 0
-
-        if self.flag_eof:
-            # This is for Linux, which requires the blocking form of waitpid to get
-            # status of a defunct process. This is super-lame. The flag_eof would have
-            # been set in read_nonblocking(), so this should be safe.
-            waitpid_options = 0
-        else:
-            waitpid_options = os.WNOHANG
-            
-        try:
-            pid, status = os.waitpid(self.pid, waitpid_options)
-        except OSError, e: # No child processes
-            if e[0] == errno.ECHILD:
-                raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?')
-            else:
-                raise e
-
-        # I have to do this twice for Solaris. I can't even believe that I figured this out...
-        # If waitpid() returns 0 it means that no child process wishes to
-        # report, and the value of status is undefined.
-        if pid == 0:
-            try:
-                pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris!
-            except OSError, e: # This should never happen...
-                if e[0] == errno.ECHILD:
-                    raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?')
-                else:
-                    raise e
-
-            # If pid is still 0 after two calls to waitpid() then
-            # the process really is alive. This seems to work on all platforms, except
-            # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking
-            # take care of this situation (unfortunately, this requires waiting through the timeout).
-            if pid == 0:
-                return 1
-
-        if pid == 0:
-            return 1
-
-        if os.WIFEXITED (status):
-            self.status = status
-            self.exitstatus = os.WEXITSTATUS(status)
-            self.signalstatus = None
-            self.terminated = 1
-            return 0
-        elif os.WIFSIGNALED (status):
-            self.status = status
-            self.exitstatus = None
-            self.signalstatus = os.WTERMSIG(status)
-            self.terminated = 1
-            return 0
-        elif os.WIFSTOPPED (status):
-            raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?')
-
-        raise ExceptionPexpect ('isalive() reached unexpected condition where waitpid matched child pid, but status was not matched by WIFEXITED, WIFSIGNALED, or WIFSTOPPED.')
-
-
-    def kill(self, sig):
-        """This sends the given signal to the child application.
-        In keeping with UNIX tradition it has a misleading name.
-        It does not necessarily kill the child unless
-        you send the right signal.
-        """
-        # Same as os.kill, but the pid is given for you.
-        if self.isalive():
-            os.kill(self.pid, sig)
-
-    def compile_pattern_list(self, patterns):
-        """This compiles a pattern-string or a list of pattern-strings.
-        Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or 
-        a list of those. Patterns may also be None which results in
-        an empty list.
-
-        This is used by expect() when calling expect_list().
-        Thus expect() is nothing more than::
-             cpl = self.compile_pattern_list(pl)
-             return self.expect_list(clp, timeout)
-
-        If you are using expect() within a loop it may be more
-        efficient to compile the patterns first and then call expect_list().
-        This avoid calls in a loop to compile_pattern_list():
-             cpl = self.compile_pattern_list(my_pattern)
-             while some_condition:
-                ...
-                i = self.expect_list(clp, timeout)
-                ...
-        """
-        if patterns is None:
-            return []
-        if type(patterns) is not types.ListType:
-            patterns = [patterns]
-
-        compiled_pattern_list = []
-        for p in patterns:
-            if type(p) is types.StringType:
-                compiled_pattern_list.append(re.compile(p, re.DOTALL))
-            elif p is EOF:
-                compiled_pattern_list.append(EOF)
-            elif p is TIMEOUT:
-                compiled_pattern_list.append(TIMEOUT)
-            elif type(p) is type(re.compile('')):
-                compiled_pattern_list.append(p)
-            else:
-                raise TypeError ('Argument must be one of StringType, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p)))
-
-        return compiled_pattern_list
- 
-    def expect(self, pattern, timeout = -1, searchwindowsize=None):
-        """This seeks through the stream until a pattern is matched.
-        The pattern is overloaded and may take several types including a list.
-        The pattern can be a StringType, EOF, a compiled re, or
-        a list of those types. Strings will be compiled to re types.
-        This returns the index into the pattern list. If the pattern was
-        not a list this returns index 0 on a successful match.
-        This may raise exceptions for EOF or TIMEOUT.
-        To avoid the EOF or TIMEOUT exceptions add EOF or TIMEOUT to
-        the pattern list.
-
-        After a match is found the instance attributes
-        'before', 'after' and 'match' will be set.
-        You can see all the data read before the match in 'before'.
-        You can see the data that was matched in 'after'.
-        The re.MatchObject used in the re match will be in 'match'.
-        If an error occured then 'before' will be set to all the
-        data read so far and 'after' and 'match' will be None.
-
-        If timeout is -1 then timeout will be set to the self.timeout value.
-
-        Note: A list entry may be EOF or TIMEOUT instead of a string.
-        This will catch these exceptions and return the index
-        of the list entry instead of raising the exception.
-        The attribute 'after' will be set to the exception type.
-        The attribute 'match' will be None.
-        This allows you to write code like this:
-                index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
-                if index == 0:
-                    do_something()
-                elif index == 1:
-                    do_something_else()
-                elif index == 2:
-                    do_some_other_thing()
-                elif index == 3:
-                    do_something_completely_different()
-        instead of code like this:
-                try:
-                    index = p.expect (['good', 'bad'])
-                    if index == 0:
-                        do_something()
-                    elif index == 1:
-                        do_something_else()
-                except EOF:
-                    do_some_other_thing()
-                except TIMEOUT:
-                    do_something_completely_different()
-        These two forms are equivalent. It all depends on what you want.
-        You can also just expect the EOF if you are waiting for all output
-        of a child to finish. For example:
-                p = pexpect.spawn('/bin/ls')
-                p.expect (pexpect.EOF)
-                print p.before
-
-        If you are trying to optimize for speed then see expect_list().
-        """
-        compiled_pattern_list = self.compile_pattern_list(pattern)
-        return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
-
-    def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1):
-        """This takes a list of compiled regular expressions and returns 
-        the index into the pattern_list that matched the child's output.
-        The list may also contain EOF or TIMEOUT (which are not
-        compiled regular expressions). This method is similar to
-        the expect() method except that expect_list() does not
-        recompile the pattern list on every call.
-        This may help if you are trying to optimize for speed, otherwise
-        just use the expect() method.  This is called by expect().
-        If timeout==-1 then the self.timeout value is used.
-        If searchwindowsize==-1 then the self.searchwindowsize value is used.
-        """
-        self.patterns = pattern_list
-
-        if timeout == -1:
-            timeout = self.timeout
-        if timeout != None:
-            end_time = time.time() + timeout 
-        if searchwindowsize == -1:
-            searchwindowsize = self.searchwindowsize
-
-        try:
-            incoming = self.buffer
-            while 1: # Keep reading until exception or return.
-                # Sequence through the list of patterns looking for a match.
-                first_match = -1
-                for cre in pattern_list:
-                    if cre is EOF or cre is TIMEOUT: 
-                        continue # The patterns for PexpectExceptions are handled differently.
-                    if searchwindowsize is None: # search everything
-                        match = cre.search(incoming)
-                    else:
-                        startpos = max(0, len(incoming) - searchwindowsize)
-                        match = cre.search(incoming, startpos)
-                    if match is None:
-                        continue
-                    if first_match > match.start() or first_match == -1:
-                        first_match = match.start()
-                        self.match = match
-                        self.match_index = pattern_list.index(cre)
-                if first_match > -1:
-                    self.buffer = incoming[self.match.end() : ]
-                    self.before = incoming[ : self.match.start()]
-                    self.after = incoming[self.match.start() : self.match.end()]
-                    return self.match_index
-                # No match at this point
-                if timeout < 0 and timeout is not None:
-                    raise TIMEOUT ('Timeout exceeded in expect_list().')
-                # Still have time left, so read more data
-                c = self.read_nonblocking (self.maxread, timeout)
-                incoming = incoming + c
-                if timeout is not None:
-                    timeout = end_time - time.time()
-        except EOF, e:
-            self.buffer = ''
-            self.before = incoming
-            self.after = EOF
-            if EOF in pattern_list:
-                self.match = EOF
-                self.match_index = pattern_list.index(EOF)
-                return self.match_index
-            else:
-                self.match = None
-                self.match_index = None
-                raise EOF (str(e) + '\n' + str(self))
-        except TIMEOUT, e:
-            self.before = incoming
-            self.after = TIMEOUT
-            if TIMEOUT in pattern_list:
-                self.match = TIMEOUT
-                self.match_index = pattern_list.index(TIMEOUT)
-                return self.match_index
-            else:
-                self.match = None
-                self.match_index = None
-                raise TIMEOUT (str(e) + '\n' + str(self))
-        except Exception:
-            self.before = incoming
-            self.after = None
-            self.match = None
-            self.match_index = None
-            raise
-
-    def getwinsize(self):
-        """This returns the window size of the child tty.
-        The return value is a tuple of (rows, cols).
-        """
-        if 'TIOCGWINSZ' in dir(termios):
-            TIOCGWINSZ = termios.TIOCGWINSZ
-        else:
-            TIOCGWINSZ = 1074295912L # Assume
-        s = struct.pack('HHHH', 0, 0, 0, 0)
-        x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s)
-        return struct.unpack('HHHH', x)[0:2]
-
-    def setwinsize(self, r, c):
-        """This sets the window size of the child tty.
-        This will cause a SIGWINCH signal to be sent to the child.
-        This does not change the physical window size.
-        It changes the size reported to TTY-aware applications like
-        vi or curses -- applications that respond to the SIGWINCH signal.
-        """
-        # Check for buggy platforms. Some Python versions on some platforms
-        # (notably OSF1 Alpha and RedHat 7.1) truncate the value for
-        # termios.TIOCSWINSZ. It is not clear why this happens.
-        # These platforms don't seem to handle the signed int very well;
-        # yet other platforms like OpenBSD have a large negative value for
-        # TIOCSWINSZ and they don't have a truncate problem.
-        # Newer versions of Linux have totally different values for TIOCSWINSZ.
-        # Note that this fix is a hack.
-        if 'TIOCSWINSZ' in dir(termios):
-            TIOCSWINSZ = termios.TIOCSWINSZ
-        else:
-            TIOCSWINSZ = -2146929561
-        if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2.
-            TIOCSWINSZ = -2146929561 # Same bits, but with sign.
-        # Note, assume ws_xpixel and ws_ypixel are zero.
-        s = struct.pack('HHHH', r, c, 0, 0)
-        fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)
-
-    def interact(self, escape_character = chr(29)):
-        """This gives control of the child process to the interactive user
-        (the human at the keyboard).
-        Keystrokes are sent to the child process, and the stdout and stderr
-        output of the child process is printed.
-        When the user types the escape_character this method will stop.
-        The default for escape_character is ^] (ASCII 29).
-        This simply echos the child stdout and child stderr to the real
-        stdout and it echos the real stdin to the child stdin.
-
-        Note that if you change the window size of the parent
-        the SIGWINCH signal will not be passed through to the child.
-        If you want the child window size to change when the parent's
-        window size changes then do something like the following example:
-            import pexpect, struct, fcntl, termios, signal, sys
-            def sigwinch_passthrough (sig, data):
-                s = struct.pack("HHHH", 0, 0, 0, 0)
-                a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s))
-                global p
-                p.setwinsize(a[0],a[1])
-            p = pexpect.spawn('/bin/bash') # Note this is global
-            signal.signal(signal.SIGWINCH, sigwinch_passthrough)
-            p.interact()
-        """
-        # Flush the buffer.
-        self.stdout.write (self.buffer)
-        self.stdout.flush()
-        self.buffer = ''
-        mode = tty.tcgetattr(self.STDIN_FILENO)
-        tty.setraw(self.STDIN_FILENO)
-        try:
-            self.__interact_copy(escape_character)
-        finally:
-            tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode)
-
-    def __interact_writen(self, fd, data):
-        """This is used by the interact() method.
-        """
-        while data != '' and self.isalive():
-            n = os.write(fd, data)
-            data = data[n:]
-    def __interact_read(self, fd):
-        """This is used by the interact() method.
-        """
-        return os.read(fd, 1000)
-    def __interact_copy(self, escape_character = None):
-        """This is used by the interact() method.
-        """
-        while self.isalive():
-            try:
-                r, w, e = select.select([self.child_fd, self.STDIN_FILENO], [], [])
-            except select.errno, e:
-                if e[0] != errno.EINTR:
-                    raise
-            if self.child_fd in r:
-                data = self.__interact_read(self.child_fd)
-                if self.logfile != None:
-                    self.logfile.write (data)
-                    self.logfile.flush()
-                os.write(self.STDOUT_FILENO, data)
-            if self.STDIN_FILENO in r:
-                data = self.__interact_read(self.STDIN_FILENO)
-                self.__interact_writen(self.child_fd, data)
-                if escape_character in data:
-                    break
-##############################################################################
-# The following methods are no longer supported or allowed..                
-    def setmaxread (self, maxread):
-        """This method is no longer supported or allowed.
-        I don't like getters and setters without a good reason.
-        """
-        raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the maxread member variable.')
-    def expect_exact (self, pattern_list, timeout = -1):
-        """This method is no longer supported or allowed.
-        It was too hard to maintain and keep it up to date with expect_list.
-        Few people used this method. Most people favored reliability over speed.
-        The implementation is left in comments in case anyone needs to hack this
-        feature back into their copy.
-        If someone wants to diff this with expect_list and make them work
-        nearly the same then I will consider adding this make in.
-        """
-        raise ExceptionPexpect ('This method is no longer supported or allowed.')
-    def setlog (self, fileobject):
-        """This method is no longer supported or allowed.
-        """
-        raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the logfile member variable.')
-
-##############################################################################
-# End of spawn class
-##############################################################################
-
-def which (filename):
-    """This takes a given filename; tries to find it in the environment path; 
-    then checks if it is executable.
-    This returns the full path to the filename if found and executable.
-    Otherwise this returns None.
-    """
-    # Special case where filename already contains a path.
-    if os.path.dirname(filename) != '':
-        if os.access (filename, os.X_OK):
-            return filename
-
-    if not os.environ.has_key('PATH') or os.environ['PATH'] == '':
-        p = os.defpath
-    else:
-        p = os.environ['PATH']
-
-    # Oddly enough this was the one line that made Pexpect
-    # incompatible with Python 1.5.2.
-    #pathlist = p.split (os.pathsep) 
-    pathlist = string.split (p, os.pathsep)
-
-    for path in pathlist:
-        f = os.path.join(path, filename)
-        if os.access(f, os.X_OK):
-            return f
-    return None
-
-def split_command_line(command_line):
-    """This splits a command line into a list of arguments.
-    It splits arguments on spaces, but handles
-    embedded quotes, doublequotes, and escaped characters.
-    It's impossible to do this with a regular expression, so
-    I wrote a little state machine to parse the command line.
-    """
-    arg_list = []
-    arg = ''
-
-    # Constants to name the states we can be in.
-    state_basic = 0
-    state_esc = 1
-    state_singlequote = 2
-    state_doublequote = 3
-    state_whitespace = 4 # The state of consuming whitespace between commands.
-    state = state_basic
-
-    for c in command_line:
-        if state == state_basic or state == state_whitespace:
-            if c == '\\': # Escape the next character
-                state = state_esc
-            elif c == r"'": # Handle single quote
-                state = state_singlequote
-            elif c == r'"': # Handle double quote
-                state = state_doublequote
-            elif c.isspace():
-                # Add arg to arg_list if we aren't in the middle of whitespace.
-                if state == state_whitespace:
-                    None # Do nothing.
-                else:
-                    arg_list.append(arg)
-                    arg = ''
-                    state = state_whitespace
-            else:
-                arg = arg + c
-                state = state_basic
-        elif state == state_esc:
-            arg = arg + c
-            state = state_basic
-        elif state == state_singlequote:
-            if c == r"'":
-                state = state_basic
-            else:
-                arg = arg + c
-        elif state == state_doublequote:
-            if c == r'"':
-                state = state_basic
-            else:
-                arg = arg + c
-
-    if arg != '':
-        arg_list.append(arg)
-    return arg_list
-

--- a/src/fdl/AcceptHandler.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/AcceptHandler.java	Wed Feb 08 18:02:40 2012 +0900
@@ -31,8 +31,11 @@
         // アクセプト処理
         SocketChannel channel = serverChannel.accept();
         channel.configureBlocking(false);
+        //channel.socket().setTcpNoDelay(true);
         fds.log(Level.INFO,"Server: accepted "+channel.socket());
 
+        // TCP N Delay を ServerSocketChannel のオプションに指定する
+        // setTcpNoDelay(boolean on) 
         tupleSpace.newUser();
 
         // 入出力用のハンドラを生成し，アタッチする

--- a/src/fdl/FDLindaServ.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/FDLindaServ.java	Wed Feb 08 18:02:40 2012 +0900
@@ -12,19 +12,19 @@
 import java.util.Iterator;
 import java.util.logging.Level;
 
-
 public class FDLindaServ  {
 	static final int MAX_REQ = 1;
 	static final int FAIL = (-1);
 	static final int DEF_PORT = 10000;
+	public static boolean debug = false;
 	public int port = DEF_PORT;
 	AbstractSelector selector;
 	private ServerSocketChannel ssChannel;
 	public TupleSpace tupleSpace;
 	public MetaEngine me;
 	
-	public static void main(final String[] args) {
-		final String usages = "usage: FDLindaServ [-p port]";
+	public static void main(MetaEngine me, final String[] args) {
+		final String usages = "usage: FDLindaServ [-d] [-p port]";
 		
 		int port = DEF_PORT;
 		//引数判定
@@ -32,7 +32,9 @@
 			for (int i=0; i<args.length; ++i) {
 				if("-p".equals(args[i])) {
 					port = Integer.parseInt(args[++i]);					
-				} 
+				} else if("-d".equals(args[i])) {
+					debug  = true;
+				}
 			}
 		} catch (NumberFormatException e) {
 			System.err.println(usages);
@@ -41,17 +43,21 @@
 		try {
 			FDLindaServ serv;
 			serv = new FDLindaServ(port);
-			serv.mainLoop();
+			serv.mainLoop(me,new MetaLinda(serv.tupleSpace, serv));
 		} catch (IOException e) {
 			System.err.println("Server Communiation Problem.");
 		}
 	}
-	
+
 	public void mainLoop() {
 		MetaLinda ml = new MetaLinda(tupleSpace, this);
-		me = new NullMetaEngine(ml);
+		me = new NullMetaEngine();
 		//me = new MetaLogEngine(ml);
-		me.mainLoop();
+		me.mainLoop(ml);
+	}
+	
+	public void mainLoop(MetaEngine me, MetaLinda ml) {
+		me.mainLoop(ml);
 	}
 
 	public FDLindaServ(int port) throws IOException {
@@ -80,8 +86,25 @@
 	}
 
 	public void checkTuple() {
-		checkTuple(0);
-	}
+		// セレクタによる監視    
+		try {
+			if (selector.selectNow()>0) {
+//              this does not work because #it.remove() is not called.
+//				for(SelectionKey s:selector.selectedKeys()) {
+//					TupleHandler handler = (TupleHandler)s.attachment();
+//					handler.handle(s);
+//				}
+			    for (Iterator<SelectionKey> it = selector.selectedKeys().iterator();it.hasNext(); ) {
+			        SelectionKey s = it.next();
+			        it.remove();
+					TupleHandler handler = (TupleHandler)s.attachment();
+					handler.handle(s);
+				}
+			}
+		} catch (ClosedChannelException e) {
+			// we have to do something...
+		} catch (IOException e) {
+		}}
 	
 	public void checkTuple(long timeout) {
 		// セレクタによる監視    
@@ -92,7 +115,7 @@
 //					TupleHandler handler = (TupleHandler)s.attachment();
 //					handler.handle(s);
 //				}
-			      for (Iterator<SelectionKey> it = selector.selectedKeys().iterator();it.hasNext(); ) {
+			    for (Iterator<SelectionKey> it = selector.selectedKeys().iterator();it.hasNext(); ) {
 			        SelectionKey s = it.next();
 			        it.remove();
 					TupleHandler handler = (TupleHandler)s.attachment();
@@ -107,8 +130,13 @@
 	
 
 	public void log(Level level,String msg) {
+		if (level!=Level.SEVERE && !debug) return;
 		System.err.println(msg);
 		if (level==Level.SEVERE)
 			new IOException().setStackTrace(null);
 	}
+
+	public static void main(final String[] args) {
+		main(new NullMetaEngine(),args);
+	}
 }

--- a/src/fdl/FederatedLinda.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/FederatedLinda.java	Wed Feb 08 18:02:40 2012 +0900
@@ -38,7 +38,7 @@
 
 	FederatedLinda fdl;
 	static int MAX_SEQUENCE = 2048;
-	static boolean debug = false;
+	public static boolean debug = false;
 
 	public int tid;
 	public int seq;
@@ -49,20 +49,28 @@
 
 	public PSXQueue q_top,q_end;
 	public PSXReply r_top,r_end;
-	public Hashtable<Integer,PSXReply> seqHash;
+	public Hashtable<Integer,PSXReply> seqHash = new Hashtable<Integer, PSXReply>();
 
 	public static FederatedLinda init() {
 		FederatedLinda fdl = new FederatedLinda();
 		return fdl;
 	}
 
+	public static FederatedLinda init(Selector selector) {
+		FederatedLinda fdl = new FederatedLinda(selector);
+		return fdl;
+	}
+	
 	private FederatedLinda() {
 		try {
 			selector = Selector.open();
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
-		seqHash =  new Hashtable<Integer, PSXReply>();
+	}
+
+	public FederatedLinda(Selector selector) {
+		this.selector = selector;
 	}
 
 	public PSXLinda open(String _host,int _port) 
@@ -116,9 +124,7 @@
 			}
 			s = new Integer(seq);
 		} while (seqHash.containsKey(s));
-		if (debug) {
-			log(Level.INFO,"hash value = "+s.hashCode());
-		}
+		// log(Level.INFO,"hash value = "+s.hashCode());
 		seqHash.put(s,reply);
 		seq++;
 		return seq-1;
@@ -128,12 +134,47 @@
 		return selector;
 	}
 
-	public int sync() throws IOException {
-		return sync(0);
+	/**
+	 * sync with no wait 
+	 * @return 0
+	 * @throws IOException
+	 */
+	public int sync()  {
+		int key_num = 0;
+		queueExec();
+
+		try {
+			if (selector.selectNow()>0) {
+				for (Iterator<SelectionKey> it = selector.selectedKeys().iterator();it.hasNext(); ) {
+					SelectionKey s = it.next();
+					it.remove();
+					try {
+						if (!s.isReadable()) 
+							throw new IOException();
+						TupleHandler handle = (TupleHandler)s.attachment();
+						handle.handle(s);
+					} catch (IOException e) {
+						s.cancel();
+						log(Level.INFO,""+s.channel()+" is closed.");
+					}
+				}
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		} catch (ClosedSelectorException e) {
+			// client should be know
+		}
+
+		return key_num;
 	}
 
-	public int sync(long mtimeout) 
-	throws IOException {
+	/**
+	 * sync with mtimeout msec wait
+	 * @param mtimeout   0 means indifinite wait
+	 * @return 0
+	 * @throws IOException
+	 */
+	public int sync(long mtimeout) {
 		int key_num = 0;
 		queueExec();
 
@@ -162,7 +203,7 @@
 		return key_num;
 	}
 
-	private void queueExec() {
+	public void queueExec() {
 		while (q_top != null){
 			PSXQueue c = q_top;
 			c.send();
@@ -180,10 +221,16 @@
 	}
 
 	public void log(Level level,String msg) {
+		if (level!=Level.SEVERE && !debug) return;
 		System.err.println(msg);
 		if (level==Level.SEVERE)
 			new IOException().setStackTrace(null);
 	}
+
+	public void wakeup() {
+		selector.wakeup();		
+	}
+
 }
 
 /* end */

--- a/src/fdl/IOHandler.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/IOHandler.java	Wed Feb 08 18:02:40 2012 +0900
@@ -9,7 +9,7 @@
 import java.util.logging.Level;
 
 public class IOHandler implements TupleHandler {
-    static final boolean debug = true;
+    static final boolean debug = false;
     public TupleSpace tupleSpace;
     public SocketChannel ch;
     public FDLindaServ fds;
@@ -67,7 +67,9 @@
     	} else if (mode == PSX.PSX_WAIT_RD) {	
 			tupleSpace.Wait_Rd(key, command, mode); 			
     	} else if(mode == PSX.PSX_OUT) {
-	    	tupleSpace.Out(key, command, data);		
+	    	tupleSpace.Out(key, command, data);
+    	} else if (mode == PSX.PSX_UPDATE){
+    		tupleSpace.Update(key, command, data);
 	    } else {
 	    	tupleSpace.hook.closeHook(key);
 		fds.log(Level.SEVERE,"Incorrect tuple operation");

--- a/src/fdl/MetaEngine.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/MetaEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -1,5 +1,6 @@
 package fdl;
 
 public interface MetaEngine {
-	void mainLoop();
+	void mainLoop(MetaLinda ml);
+
 }
\ No newline at end of file

--- a/src/fdl/MetaLinda.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/MetaLinda.java	Wed Feb 08 18:02:40 2012 +0900
@@ -30,13 +30,15 @@
 
 	public TupleSpace ts;
 	public FDLindaServ fds;
-	public FederatedLinda fdl=FederatedLinda.init();
+	public FederatedLinda fdl;
 	public PSXLinda next=null;
-	private LinkedList<MetaReply> replies=new LinkedList<MetaReply>();
+	public LinkedList<MetaReply> replies=new LinkedList<MetaReply>();
 
 	public MetaLinda(TupleSpace ts,FDLindaServ fds) {
 		this.ts = ts;
 		this.fds = fds;
+		// Selector have to be shared with FDLindaServ and FederatedLInda
+		fdl=FederatedLinda.init(fds.selector);
 	}
 
 	public PSXLinda open(String _host,int _port) 
@@ -95,37 +97,70 @@
 		addReply(r);
 	}
 
+
+	public void waitRd(int id, PSXCallback callback) {
+		MetaReply r = new MetaReply(PSX.PSX_WAIT_RD,id,ts,callback);
+		addReply(r);
+	}
+
+	public PSXReply waitRd(int id) {
+		MetaReply r = new MetaReply(PSX.PSX_WAIT_RD,id,ts);
+		return r;
+	}
+	
 	public PSXLinda add(PSXLinda linda) {
 		next = linda;
 		return this;
 	}
 
-
+	/**
+	 * Meta Sync with no wait
+	 */
 	public int sync() {
-		return sync(0);
+		fdl.queueExec();
+		fds.checkTuple(); // fdl sync is also handled here
+		return metaSync();
 	}
 
+	/**
+	 * Meta Sync with wait
+	 * @param timeout wait timeout msec, if 0 wait indefinitely
+	 */
 	public int sync(long timeout) {
+		fdl.queueExec();
 		fds.checkTuple(timeout); // fdl sync is also handled here
+		return metaSync();
+	}
+		
+	public int metaSync() {
 		/*
 		 * r.callback() may call meta.sync() and modifies the
 		 * replies queue. Do current size of queue only. The
 		 * rest is checked on the next sync call including
 		 * the recursive case.
 		 */
-		int count = replies.size();
-		while(count-->0) {
-			MetaReply r = replies.poll();
-			// previous call back may call this sync and make 
-			// replies shorter.
-			if (r==null) break;
-			if (r.ready()) {
-			} else {
-				addReply(r);
+		boolean hasNewReply;
+		do {
+			hasNewReply = false;
+			int count = replies.size();
+			while (count-->0) {
+				MetaReply r = replies.poll();
+				// previous call back may call this sync and make 
+				// replies shorter.
+				if (r==null) break;
+				if (r.ready()) {
+					hasNewReply = true;
+				} else {
+					addReply(r);
+				}
 			}
-		}
+		} while (hasNewReply);
 		return 0;
 	}
+	
+	public void wakeup() {
+		fdl.wakeup();
+	}
 
 	public void send(ByteBuffer command, ByteBuffer data) {
 	}

--- a/src/fdl/MetaLogEngine.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/MetaLogEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -28,7 +28,7 @@
 			do {
 				data = commDebug.getLog();
 				if (data!=null) break;
-				meta.sync();
+				meta.sync(0);
 			} while (running);
 			if (running) {
 				meta.out(PSX.META_MONITOR_DATA, data);
@@ -36,11 +36,11 @@
 			}
 		}};
 	
-	public void mainLoop() {
+	public void mainLoop(MetaLinda meta) {
 		meta.in(PSX.META_MONITOR,monitor_callback_start);
 		meta.in(PSX.META_STOP, new PSXCallback() {public void callback(ByteBuffer reply) {
 			running = false;}});
 		while(running) 
-			meta.sync();
+			meta.sync(0);
 	}
 }

--- a/src/fdl/MetaReply.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/MetaReply.java	Wed Feb 08 18:02:40 2012 +0900
@@ -52,10 +52,14 @@
 			ts.Out(null, command, data);
 			return true;
 		case PSX.PSX_UPDATE:
-			// not implemented
+			// TODO: not implemented
 			break;
 		}
 		return mode==PSX.PSX_ANSWER;
 	}
+	
+	public String toString() {
+		return "MetaReply(mode="+mode+"+id="+id+")";
+	}
 
 }

--- a/src/fdl/NullMetaEngine.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/NullMetaEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -3,17 +3,17 @@
 import java.nio.ByteBuffer;
 
 public class NullMetaEngine implements MetaEngine {
-	public MetaLinda meta;
 	public boolean running=true;
 
-	public NullMetaEngine(MetaLinda meta) {
-		this.meta = meta;
+	public NullMetaEngine() {
 	}
 	
-	public void mainLoop() {
+	public void mainLoop(MetaLinda meta) {
 		meta.in(PSX.META_STOP, new PSXCallback() {public void callback(ByteBuffer reply) {
 			running = false;}});
 		while(running) 
-			meta.sync();
+			meta.sync(0);
 	}
+
+
 }

--- a/src/fdl/PSX.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/PSX.java	Wed Feb 08 18:02:40 2012 +0900
@@ -218,7 +218,7 @@
     		System.err.println("read size mismatch"+readsize+" and "+command.capacity());
 		}
 		while(readsize>0) {
-	    	if(false && IOHandler.debug){
+	    	if(IOHandler.debug){
 	    		System.out.println("reading packet..."+readsize);
 	    	}
 	    	count = channel.read(command);

--- a/src/fdl/PSXLinda.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/PSXLinda.java	Wed Feb 08 18:02:40 2012 +0900
@@ -3,32 +3,129 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 
+/**
+ * @author kono
+ *
+ */
 public interface PSXLinda {
 
-
+	
+	/**
+	 * send IN request to the linda
+	 * Tuple with id will be removed, and the value is returned in the reply
+	 * @param id
+	 * @return wait for this request
+	 */
 	public PSXReply in(int id) ;
 
+	/**
+	 * send IN request and set call back for reply
+	 * @param id
+	 * @param callback
+	 */
 	public void in(int id, PSXCallback callback);
 
+	/**
+	 * send Check request to the Linda
+	 * Tuple with id will not be removed, it return even if there is no tuple for
+	 * this id
+	 * @param id
+	 * @return wait for this request
+	 */
 	public PSXReply ck(int id) ;
 
+	/**
+	 * send Check request and set call back for reply
+	 * @param id
+	 * @param callback
+	 */
 	public void ck(int id, PSXCallback callback) ;
 
+	/**
+	 * send a Tuple to the linda
+	 * Tuple may stack in the linda, multiple out is possible.
+	 * No blocking.
+	 * this id
+	 * @param id
+	 * @return wait for this request
+	 */
 	public PSXReply out(int id, ByteBuffer data) ;
 
+	/**
+	 * replace a Tuple in the linda
+	 * the old value is returned in the reply
+	 * @param id
+	 * @return wait for this request
+	 */
 	public PSXReply update(int id, ByteBuffer data) ;
 
+	/**
+	 * send Update request and set call back for reply
+	 * @param id
+	 * @param callback
+	 */
 	public void update(int id, ByteBuffer data,PSXCallback callback) ;
 
+	/**
+	 * Read the tuple in the linda, do not remove the tuple.
+	 * it return it's value
+	 * @param id
+	 * @return wait for this request
+	 */
 	public PSXReply rd(int id) ;
 
+	/**
+	 * send Read request and set call back for reply
+	 * @param id
+	 * @param callback
+	 */
 	public void rd(int id, PSXCallback callback) ;
 
-	public PSXLinda add(PSXLinda linda) ;
+
+	/**
+	 * Wait for newly incoming tuple for this id. 
+	 * Existing tuple is ignored.
+	 * Read the tuple in the linda, do not remove the tuple.
+	 * it return it's value
+	 * @param id
+	 * @return wait for this request
+	 */
+	public PSXReply waitRd(int i);
 
+	/**
+	 * send Read request and set call back for reply
+	 * @param id
+	 * @param callback
+	 */
+	public void waitRd(int i, PSXCallback callback);
+	
+	/**
+	 * Send all registered requests, and read incoming replies.
+	 * No wait
+	 * @return
+	 * @throws IOException
+	 */
 	public int sync() throws IOException ;
 
+	/**
+	 * Send all registered requests, and read incoming replies.
+	 * @param mtime     wait for mtime msec, if 0 this waits indefinitely.
+	 * @return
+	 * @throws IOException
+	 */
 	public int sync(long mtime) throws IOException ;
 
+	/**
+	 * Internal use
+	 * @param linda
+	 * @return
+	 */
+	public PSXLinda add(PSXLinda linda) ;
+	
+	/*
+	 * Intenal use
+	 * sned data for this port
+	 */
 	public void send(ByteBuffer command, ByteBuffer data);
+
 }

--- a/src/fdl/PSXLindaImpl.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/PSXLindaImpl.java	Wed Feb 08 18:02:40 2012 +0900
@@ -65,12 +65,6 @@
 			if (debug) {
 			    fdl.log(Level.INFO,"waiting for connect");
 			}
-			if (false) {
-				try {
-					wait(2000);
-				} catch (InterruptedException e) {
-				}
-			}
 		}
 		fdl.log(Level.INFO,"Linda client connect to "+socketChannel);
         socketChannel.register(selector,SelectionKey.OP_READ,this);
@@ -117,6 +111,15 @@
 		}
 	}
 
+	public void close() {
+		if (socketChannel != null) {
+			try {
+				socketChannel.close();
+			} catch (IOException e) {
+			}
+		}
+	}
+
 	private void checkConnect(String s) {
 		fdl.log(Level.INFO, "Connected:"+ s +": "
 		    +socketChannel.isConnected());
@@ -183,6 +186,15 @@
 	}
 
 
+	public PSXReply waitRd(int id) {
+		PSXReply r = fdl.psx_queue(this, id, null, PSX.PSX_WAIT_RD, null);
+		return r;
+	}
+
+	public void waitRd(int id, PSXCallback callback) {
+		fdl.psx_queue(this, id, null, PSX.PSX_WAIT_RD, callback);
+	}
+
 }
 
 

--- a/src/fdl/TupleSpace.java	Wed Feb 08 18:02:00 2012 +0900
+++ b/src/fdl/TupleSpace.java	Wed Feb 08 18:02:40 2012 +0900
@@ -39,6 +39,8 @@
         ByteBuffer data = ByteBuffer.allocate(10);
         ByteBuffer r = ByteBuffer.allocate(10);
         int value = user;
+        
+        r.put((byte) '\0');
         while(value>0) {
             r.put((byte) (value%10 + '0'));
             value /= 10;
@@ -55,13 +57,18 @@
 	}
 	
 	protected void Out(SelectionKey key,ByteBuffer command, ByteBuffer data) {
-		Tuple tuple;
-		int id;
-		int datasize;
 		char idc = (char)command.getShort(PSX.LINDA_ID_OFFSET);
 		command.rewind();
-		id = (int)idc;
+		int id = (int)idc;
+
+		Out1(key, command, data, id);
+	}
 
+
+	private void Out1(SelectionKey key, ByteBuffer command, ByteBuffer data,
+			int id) {
+		Tuple tuple;
+		int datasize;
 		datasize = command.getInt(PSX.LINDA_DATA_LENGTH_OFFSET);
 		command.rewind();
 		
@@ -75,7 +82,7 @@
 			PSX.setAnserCommand(command, tuple_space[id].getSeq());
 			PSX.send(tuple_space[id].ch, command, data);
 
-			removeTuple(id);
+			tuple_space[id] = tuple_space[id].next;
 			tuple = null;
 		}
 		if(tuple_space[id] != null && tuple_space[id].mode == PSX.PSX_IN) {
@@ -85,7 +92,7 @@
 				if (debug) fds.log(Level.INFO,"send size "+datasize+" : mode = "+(char)'a');
 			}
 			PSX.send(tuple_space[id].ch, command, data);
-			removeTuple(id);
+			tuple_space[id] = tuple_space[id].next;
 			tuple = null;
 			// Incoming Out tuple is consumed here, and wating IN tuple is also removed.
 		} else if ((tuple_space[id] == null)|| (tuple_space[id].getMode() == PSX.PSX_OUT)) {
@@ -111,13 +118,26 @@
 		}
 	}
 
-	private void removeTuple(int id) {
-		Tuple tuple;
-		//後処理
-		tuple = tuple_space[id];
-		tuple_space[id] = tuple.next;
+	protected void Update(SelectionKey key, ByteBuffer command, ByteBuffer data) {
+		char idc = (char)command.getShort(PSX.LINDA_ID_OFFSET);
+		command.rewind();
+		int id = (int)idc;
+
+		Tuple tuple = tuple_space[id];
+		if (tuple != null) {
+			while (tuple.next != null)
+				tuple = tuple.next;
+			tuple.id = id;
+			tuple.setCommand(PSX.PSX_ANSWER, command.getInt(PSX.LINDA_SEQ_OFFSET));
+		} else {
+			tuple = new Tuple();
+			tuple.setCommand(PSX.PSX_ANSWER, id, command.getInt(PSX.LINDA_SEQ_OFFSET), ByteBuffer.allocate(0));
+		}
+		PSX.send(key, tuple.getCommand(), tuple.getData());
+		tuple_space[id] = null; 
+		Out1(key, command, data, id);
 	}
-
+	
 	protected void Wait_Rd(SelectionKey key, ByteBuffer command, int mode) {
 		Tuple tuple;
 		int id;
@@ -291,5 +311,4 @@
 		return data;
 	}
 
-
 }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/multiengine/MultiEngineServer.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,19 @@
+package fdl.multiengine;
+
+import fdl.FDLindaServ;
+import fdl.multiengine.meta.MetaEngineExecutor;
+import fdl.multiengine.meta.StopServerEngine;
+
+public class MultiEngineServer {
+	static MetaEngineExecutor mee;
+	
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		mee = new MetaEngineExecutor();
+		mee.addMetaEngine(new StopServerEngine(mee));
+		FDLindaServ.main(mee, args); // start server
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/multiengine/TupleClassLoader.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,45 @@
+package fdl.multiengine;
+
+import java.nio.ByteBuffer;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+
+import fdl.MetaEngine;
+import fdl.MetaLinda;
+import fdl.protobuf.TupleClass.ClassFile;
+
+public class TupleClassLoader extends ClassLoader implements MetaEngine {
+	public String name;
+	private byte[] file;
+	private Class<MetaEngine> clazz;
+	
+	@SuppressWarnings("unchecked")
+	public TupleClassLoader(ByteBuffer protoc) {
+		try {
+			ClassFile classFile = ClassFile.parseFrom(protoc.array());
+			name = classFile.getName();
+			file = classFile.getFile().toByteArray();
+			clazz = (Class<MetaEngine>) findClass(name);
+		} catch (InvalidProtocolBufferException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	@Override
+	public Class<?> findClass(String name) {
+		return defineClass(name, file, 0, file.length);
+	}
+
+	public void mainLoop(MetaLinda ml) {
+		@SuppressWarnings("rawtypes")
+		Class[] parameter = { MetaLinda.class };
+		try {
+			clazz.getMethod("mainLoop", parameter);
+		} catch (SecurityException e) {
+			e.printStackTrace();
+		} catch (NoSuchMethodException e) {
+			e.printStackTrace();
+		}
+	}
+	
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/multiengine/TupleId.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,39 @@
+package fdl.multiengine;
+
+import java.util.HashMap;
+
+public enum TupleId {
+	MANAGE (60000),
+	STOP;
+	
+	public int id;
+	public static HashMap<Integer, TupleId> hash = new HashMap<Integer, TupleId>();
+	private static int lastId = 0; 
+
+	private TupleId(int id) {
+		this.id = id;
+		setLastId(id);
+	}
+	
+	private TupleId() {
+		this.id = incrementLastId();
+	}
+	
+	private void setLastId(int id) {
+		lastId = id;
+	}
+	
+	private int incrementLastId() {
+		return ++lastId;
+	}
+	
+	public static TupleId getTupleIdFromId(int id) {
+		return hash.get(id);
+	}
+	
+	static {
+		for (TupleId tid : TupleId.values()) {
+			hash.put(tid.id, tid);
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/multiengine/meta/MetaEngineExecutor.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,33 @@
+package fdl.multiengine.meta;
+
+import java.util.LinkedList;
+
+import fdl.MetaEngine;
+import fdl.MetaLinda;
+
+public class MetaEngineExecutor implements MetaEngine {
+	private LinkedList<MetaEngine> engines;
+	public boolean running = true;
+
+	public MetaEngineExecutor() {
+		engines = new LinkedList<MetaEngine>();
+	}
+	
+	public void mainLoop(MetaLinda ml) {
+		while (running) {
+			for (MetaEngine engine : engines) {
+				engine.mainLoop(ml);
+			}
+			ml.sync(0);
+		}
+	}
+	
+	public void addMetaEngine(MetaEngine engine) {
+		engines.add(engine);
+	}
+	
+	public void removeMetaEngine(MetaEngine engine) {
+		engines.remove(engine);
+	}
+	
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/multiengine/meta/StopServerEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,24 @@
+package fdl.multiengine.meta;
+
+import java.nio.ByteBuffer;
+
+import fdl.MetaEngine;
+import fdl.MetaLinda;
+import fdl.PSXCallback;
+import fdl.multiengine.TupleId;
+
+public class StopServerEngine implements MetaEngine {
+	MetaEngineExecutor mee;
+
+	public StopServerEngine(MetaEngineExecutor mee) {
+		this.mee = mee;
+	}
+	
+	public void mainLoop(MetaLinda ml) {
+		ml.in(TupleId.STOP.id,
+				new PSXCallback() { public void callback(ByteBuffer reply) {
+					mee.running = false; }});
+		mee.removeMetaEngine(this);
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/FDLServWithSend.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,23 @@
+package fdl.old.test.metaTransfer;
+
+import java.io.IOException;
+
+import fdl.FDLindaServ;
+import fdl.MetaLinda;
+
+
+public class FDLServWithSend extends FDLindaServ {
+	int port1;
+	public FDLServWithSend(int port,int port1) throws IOException {
+		super(port);
+		this.port1 = port1;
+	}
+
+	@Override public void mainLoop() {
+		System.out.println("change mainloop");
+		MetaLinda ml = new MetaLinda(this.tupleSpace,this);
+		MetaProtocolEngine mpe = new MetaProtocolEngine(ml,"MetaEngine", port1);
+		mpe.mainLoop(ml);
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/MetaProtocolEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,95 @@
+package fdl.old.test.metaTransfer;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import fdl.MetaEngine;
+import fdl.MetaLinda;
+import fdl.PSXLinda;
+import fdl.PSXReply;
+
+public class MetaProtocolEngine implements MetaEngine {
+	private int id = 10;
+	private boolean running = true;
+	
+	private PSXLinda psx;
+	private String name;
+	MetaLinda fdl1;
+	String host = "127.0.0.1";
+	int port1;
+	private PSXLinda psx1;
+	private ByteBuffer data2 = ByteBuffer.allocate(10);
+	private int count = 1;
+
+	
+	public MetaProtocolEngine(MetaLinda ml, String string, int port1) {
+		this.name = string;
+		this.port1 = port1;
+		this.fdl1 = ml;
+	}
+
+	public void mainLoop(MetaLinda ml){
+		boolean connect = true;
+		System.out.println("MetaEngine Start");
+		while(connect){
+		try {
+			initConnect();
+			transfer();
+			connect = false;
+		} catch (IOException e) {
+			try {
+				Thread.sleep(40);
+			} catch (InterruptedException e1) {
+			}
+		}
+		}
+	}
+
+	private void initConnect(){
+		System.out.println(name);
+		boolean connectpsx = true;
+		while(connectpsx){
+		try {
+			psx = fdl1.open(host,port1);
+			connectpsx = false;
+		} catch (IOException e) {
+			try {
+				Thread.sleep(40);
+			} catch (InterruptedException e1) {
+				e1.printStackTrace();
+			}
+		}
+		}
+		System.out.println("Connect "+port1);
+		psx1 = fdl1;
+	}
+
+	private void transfer() throws IOException {
+		PSXReply in = psx.in(id);
+		System.out.println("PSXReply "+port1);
+		while (running) {
+			if(in.ready()){
+				data2 = in.getData();
+				int i = data2.getInt();
+				data2.rewind();
+				//outしたbytebufferの変更をこれ以降やっちゃいけない
+				psx1.out(id,data2);
+				
+				System.out.println("IntData0 "+port1 +i);
+				fdl1.sync(0);
+				if (count++>3) {
+					running = false;
+					break;
+				}
+				System.out.println("IntData1 "+port1 +i);
+			}
+			fdl1.sync(0);
+		}
+		assertEquals(4,count);
+	}
+
+	
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/MetaProtocolEngine_not.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,69 @@
+package fdl.old.test.metaTransfer;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import fdl.FederatedLinda;
+import fdl.MetaEngine;
+import fdl.MetaLinda;
+import fdl.PSXLinda;
+import fdl.PSXReply;
+
+
+public class MetaProtocolEngine_not implements MetaEngine {
+	private FederatedLinda fdlmeta;
+	private ByteBuffer data = ByteBuffer.allocate(1024);
+	private int id = 10;
+	private boolean running = true;
+	
+	//ここからsend用宣言
+	private PSXLinda sendpsx,getpsx;
+	private String host = "127.0.0.1";
+	private int port;
+			
+	public MetaProtocolEngine_not(MetaLinda fdlmeta, int port) {
+		this.port = port;
+	}
+	
+	public void metaOpen(int sendport){
+		try{
+		sendpsx = fdlmeta.open(host, sendport);
+		}catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	//meta部分のデータ取得
+	public void metaTrans() {
+		try {
+			getpsx = fdlmeta.open(host, 10001);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		PSXReply in = getpsx.in(id);
+		while (running) {
+			System.out.println(in);
+			System.out.println(in.ready());
+		if(in.ready()) {
+			data = in.getData();
+			sendpsx.out(id, data);
+			running = false;
+			break;
+		}
+		}
+	}
+
+	
+	public void mainLoop(MetaLinda ml) {
+		System.out.println("MetaProtocolEngine Start");
+		fdlmeta = FederatedLinda.init();
+		if( port == 10002 ) {
+			metaOpen(10003);
+			metaTrans();
+			fdlmeta.sync();
+			System.out.println("MetaProtocolEngine Connect");
+		}
+
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Ring/FDLServWithSend.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,22 @@
+package fdl.old.test.metaTransfer.Ring;
+
+import java.io.IOException;
+
+import fdl.FDLindaServ;
+import fdl.MetaLinda;
+
+public class FDLServWithSend extends FDLindaServ {
+	int port1;
+	public FDLServWithSend(int port,int port1) throws IOException {
+		super(port);
+		this.port1 = port1;
+	}
+	
+	@Override public void mainLoop() {
+		System.out.println("change mainloop");
+		MetaLinda ml = new MetaLinda(this.tupleSpace,this);
+		MetaProtocolEngine mpe = new MetaProtocolEngine(ml,"MetaEngine", port1, port1);
+		mpe.mainLoop(ml);
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Ring/MetaProtocolEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,100 @@
+package fdl.old.test.metaTransfer.Ring;
+
+//import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import fdl.MetaEngine;
+import fdl.MetaLinda;
+import fdl.PSXLinda;
+import fdl.PSXReply;
+
+public class MetaProtocolEngine implements MetaEngine {
+	int id = 10;
+	private boolean running = true;
+	
+	private PSXLinda psx;
+	private String name;
+	MetaLinda fdl1;
+	String host = "127.0.0.1";
+	int port1;
+	private PSXLinda psx1;
+	private ByteBuffer data = ByteBuffer.allocate(10);
+//	private int count = 1;
+	int port;
+
+	
+	public MetaProtocolEngine(MetaLinda ml, String string, int port1, int port) {
+		this.name = string;
+		this.port1 = port1;
+		this.fdl1 = ml;
+		this.port = port;
+	}
+
+	public void mainLoop(MetaLinda ml){
+		boolean connect = true;
+		System.out.println("MetaEngine Start");
+		while(connect){
+		try {
+			initConnect();
+			transfer(psx, psx1);
+			connect = false;
+		} catch (IOException e) {
+			try {
+				Thread.sleep(40);
+			} catch (InterruptedException e1) {
+			}
+		}
+		}
+	}
+
+	private void initConnect() throws IOException{
+		System.out.println(name);
+		//自分
+		psx = fdl1;
+		if (port == 10001){
+			sendData();
+			}
+		//相手
+		psx1 = fdl1.open(host,port1);
+		System.out.println("Connect "+port1);
+	}
+
+	private void sendData() throws IOException{
+		boolean connectSend = true;
+		ByteBuffer send = ByteBuffer.allocate(1024);
+		send.putInt(12);
+		send.flip();
+		while(connectSend){
+		psx.out(id, send);
+		fdl1.sync(1);
+		System.out.println("Send Data 10001");
+		connectSend = false;
+		}
+	}
+	
+	private void transfer(PSXLinda getpsx, PSXLinda sendpsx) throws IOException {
+		PSXReply in = getpsx.in(id);
+		System.out.println("PSXReply "+port1);
+		while (running) {
+			if(in.ready()){
+				data = in.getData();
+				int i = data.getInt();
+				data.rewind();
+				//outしたbytebufferの変更をこれ以降やっちゃいけない
+				sendpsx.out(id,data);
+				
+				System.out.println("IntData0 "+port1 +i);
+				fdl1.sync(1);
+				running = false;
+				System.out.println("IntData1 "+port1 +i);
+				break;
+			}
+			fdl1.sync(0);
+			}
+//		assertEquals(4,count);
+	}
+
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Ring/Server.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,39 @@
+package fdl.old.test.metaTransfer.Ring;
+
+import java.io.IOException;
+
+import fdl.FDLindaServ;
+
+public class Server extends Thread {
+	int port1;
+	int port2;
+	int set;
+	private String name;
+	
+	public Server(String string, int i, int t, int s) {
+		port1 = i;
+		port2 = t;
+		name = string;
+		set = s;
+	}
+
+	public void run(){
+		String[] args = {"-p",Integer.toString(port1)};
+		System.out.println(name);
+		switch (set){
+		case 0:
+		try {
+			FDLServWithSend send = new FDLServWithSend(port1,port2);
+			send.mainLoop();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		break;
+		
+		case 1:
+		FDLindaServ.main(args);
+		break;
+		}
+	}
+
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Ring/TestSend.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,47 @@
+package fdl.old.test.metaTransfer.Ring;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import fdl.FederatedLinda;
+import fdl.PSXLinda;
+
+public class TestSend extends Thread {
+	PSXLinda psxsend;
+	FederatedLinda fdlsend;
+	
+	public void run(){
+		int id = 10;
+		int port = 10001;
+		boolean connect = true;
+		String host = "127.0.0.1";
+		ByteBuffer send = ByteBuffer.allocate(1024);
+		send.putInt(12);
+		send.flip();
+		while(connect){
+		try {
+		sendData(id, port, host, send);
+		connect = false;
+		} catch(IOException e) {
+			try {
+				Thread.sleep(40);
+			} catch (InterruptedException e1) {
+				e1.printStackTrace();
+			}
+		}
+		
+		}
+	}
+
+	private void sendData(int id, int port, String host, ByteBuffer send) throws IOException {
+		fdlsend = FederatedLinda.init();
+
+			psxsend = fdlsend.open(host,port);
+			System.out.println("Connect Host1");
+			psxsend.out(id, send);
+			fdlsend.sync(1);
+			System.out.println("Send Data");
+
+	}
+	
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Ring/TestTransfer.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,29 @@
+package fdl.old.test.metaTransfer.Ring;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+public class TestTransfer {
+	@Test
+	public void testTransfer() throws IOException {
+		int port1 = 10001;
+		int port2 = 10002;
+		
+		Server server1 = new Server("Server1",port1, port2,0);
+		server1.start();
+
+		Server server2 = new Server("Server2",port2, port1,1);
+		server2.start();
+		
+		try {
+			server2.join();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		
+		assertEquals(1,1);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Ring/TestTransferRing.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,40 @@
+package fdl.old.test.metaTransfer.Ring;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class TestTransferRing {
+	Server[] servers;
+	final int serverCount = 3;
+	final int startPort = 10001;
+	@Test
+	public void testTransfer() {
+		int port = startPort;
+		
+		servers = new Server[serverCount];
+		
+		for (int i = 0; i < serverCount; i++) {
+			servers[i] = new Server("Server"+(i+1),port+i,netporot(port+i),0);
+			servers[i].start();
+		}
+		
+//		try {
+//			servers[3].join();
+//		} catch (InterruptedException e) {
+//			e.printStackTrace();
+//		}
+		
+
+		assertEquals(1,1);
+	}
+	private int netporot(int i) {
+		i++;
+		if(i >= startPort+serverCount) {
+			return startPort;
+		}
+		
+		return i;
+	}
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Ring/TestTransferThree.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,22 @@
+package fdl.old.test.metaTransfer.Ring;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class TestTransferThree {
+	@Test
+	public void testTransfer() {
+		
+		Server server1 = new Server("Server1", 10001, 10002, 0);
+		server1.start();
+		Server server2 = new Server("Server2", 10002, 10001, 0);
+		server2.start();
+//		Server server3 = new Server("Server3", 10003, 10001, 0);
+//		server3.start();
+
+		assertEquals(1,1);
+	}
+
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/Server.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,20 @@
+package fdl.old.test.metaTransfer;
+
+import fdl.FDLindaServ;
+
+public class Server extends Thread {
+	int port;
+	private String name;
+	
+	public Server(String string, int i) {
+		port = i;
+		name = string;
+	}
+
+	public void run(){
+		String[] args = {"-p",Integer.toString(port)};
+		System.out.println(name);
+		FDLindaServ.main(args);
+	}
+
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/TestSend.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,47 @@
+package fdl.old.test.metaTransfer;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import fdl.FederatedLinda;
+import fdl.PSXLinda;
+
+public class TestSend extends Thread {
+	PSXLinda psxsend;
+	FederatedLinda fdlsend;
+	
+	public void run(){
+		int id = 10;
+		int port = 10001;
+		boolean connect = true;
+		String host = "127.0.0.1";
+		ByteBuffer send = ByteBuffer.allocate(1024);
+		send.putInt(12);
+		send.flip();
+		while(connect){
+		try {
+		sendData(id, port, host, send);
+		connect = false;
+		} catch(IOException e) {
+			try {
+				Thread.sleep(40);
+			} catch (InterruptedException e1) {
+				e1.printStackTrace();
+			}
+		}
+		
+		}
+	}
+
+	private void sendData(int id, int port, String host, ByteBuffer send) throws IOException {
+		fdlsend = FederatedLinda.init();
+
+			psxsend = fdlsend.open(host,port);
+			System.out.println("Connect Host1");
+			psxsend.out(id, send);
+			fdlsend.sync(1);
+			System.out.println("Send Data");
+
+	}
+	
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/metaTransfer/TestTransfer.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,27 @@
+package fdl.old.test.metaTransfer;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+public class TestTransfer {
+	@Test
+	public void testTransfer() throws IOException {
+		int port1 = 10001;
+		int port2 = 10002;
+		
+//		Server server1 = new Server("Server1",port1);
+//		server1.start();
+//
+		Server server2 = new Server("Server2",port2);
+		server2.start();
+		
+
+		FDLServWithSend send = new FDLServWithSend(port1, port2);
+		send.mainLoop();
+		
+		assertEquals(1,1);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/ProtocolEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,74 @@
+package fdl.old.test.transfer;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import fdl.FederatedLinda;
+import fdl.PSXLinda;
+import fdl.PSXReply;
+
+
+public class ProtocolEngine extends Thread{
+	private PSXLinda psx;
+	private String name;
+	FederatedLinda fdl1;
+	String host = "127.0.0.1";
+	int port1 = 10001;
+	int port2 = 10002;
+	private int id = 10;
+	private PSXLinda psx1;
+	private boolean running = true;
+	private ByteBuffer data2 = ByteBuffer.allocate(10);
+
+	public ProtocolEngine(String string, int port1, int port2) {
+		this.name = string;
+		this.port1 = port1;
+		this.port2 = port2;
+	}
+
+	public void run(){
+		fdl1 = FederatedLinda.init();
+		try {
+			System.out.println(name);
+			psx = fdl1.open(host,port1);
+			System.out.println("Connect Host1");
+			psx1 = fdl1.open(host,port2);
+			System.out.println("Connect Host2");
+			// Host1にデータを送信する。
+			testSend(psx);
+			// psxにデータを用意
+			transfer(psx,psx1);
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private void testSend(PSXLinda psx2) throws IOException {
+		ByteBuffer send = ByteBuffer.allocate(10);
+		send.putInt(12);
+		send.flip();
+		psx2.out(id, send);
+		psx2.sync(1);
+	}
+	
+
+	private void transfer(PSXLinda getpsx, PSXLinda sendpsx) throws IOException {
+		PSXReply in = getpsx.in(id);
+		while (running) {
+			System.out.println(in.ready());
+			if(in.ready()){
+				//psx1にデータを書き出し
+				data2 = in.getData();
+				sendpsx.out(id,data2);
+				//runningフラグをfalseする
+				running = false;
+				fdl1.sync(0);
+				break;
+			}
+			fdl1.sync();
+		}
+		
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/Server.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,20 @@
+package fdl.old.test.transfer;
+
+import fdl.FDLindaServ;
+
+public class Server extends Thread{
+	int port;
+	private String name;
+
+	public Server(String string, int i) {
+		port = i;
+		name = string;
+	}
+
+	public void run(){
+		String[] args = {"-p",Integer.toString(port)};
+		System.out.println(name);
+		FDLindaServ.main(args);
+	}
+
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/TestSend.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,33 @@
+package fdl.old.test.transfer;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import fdl.FederatedLinda;
+import fdl.PSXLinda;
+
+public class TestSend extends Thread {
+	PSXLinda psxsend;
+	FederatedLinda fdlsend;
+	
+	public void run(){
+		int id = 10;
+		int port = 10001;
+		String host = "127.0.0.1";
+		ByteBuffer send = ByteBuffer.allocate(1024);
+		send.putInt(12);
+		send.flip();
+		fdlsend = FederatedLinda.init();
+		try{
+			psxsend = fdlsend.open(host,port);
+			System.out.println("Connect Host1");
+			psxsend.out(id, send);
+			fdlsend.sync();
+			System.out.println("Send Data");
+		}catch (IOException e) {
+			System.out.println("例外：" + e);
+		}
+		
+	}
+	
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/TestTransfer.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,25 @@
+package fdl.old.test.transfer;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class TestTransfer {
+	@Test
+	public void testTransfer() {
+		int port1 = 10001;
+		int port2 = 10002;
+		Server server1 = new Server("Server1",port1);
+		server1.start();
+		Server server2 = new Server("Server2",port2);
+		server2.start();
+		ProtocolEngine pe = new ProtocolEngine("ProtocolEngine",port1,port2);
+		pe.start();
+		try {
+			pe.join();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		assertEquals(1,1);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/cluster/FDLServWithSendMeta.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,91 @@
+package fdl.old.test.transfer.cluster;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+import fdl.FDLindaServ;
+import fdl.MetaLinda;
+
+
+public class FDLServWithSendMeta extends FDLindaServ {
+
+	public FDLServWithSendMeta(int port) throws IOException {
+		super(port);
+	}
+	
+	static String nextHost = null;
+	private static int localport = 10000;
+	static int chknum;
+	private static String bufstring;
+	private static int bufsize;
+	private static String txt;
+	private static int ring;
+	
+	@Override public void mainLoop() {
+		MetaLinda ml = new MetaLinda(tupleSpace, this);
+		MetaProtocolEngine mpe = new MetaProtocolEngine(ml, nextHost, chknum, bufsize, txt);
+		mpe.mainLoop(ml);
+	}
+	
+	public static void main(String[] args){
+		for (int k=0; k<args.length; ++k) {
+			if("-bufsize".equals(args[k])){
+				bufstring = args[++k];
+			} else if("-ring".equals(args[k])){
+				txt = args[++k];
+				ring = Integer.valueOf(txt);
+			} else {
+				System.err.println("引数指定の誤り：未知の引数が指定されました");
+            }
+		}
+		bufsize = Integer.parseInt(bufstring);
+		try {
+			chkhost();
+			FDLServWithSendMeta serv = new FDLServWithSendMeta(localport);
+			serv.mainLoop();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private static void chkhost() throws UnknownHostException{
+		String localhost = null;
+		BufferedReader br = null;
+		String hostTable[] = new String[ring+1];
+		try {
+			br = new BufferedReader(new FileReader("nodelist"));
+			int i = 0;
+			while (br.ready()) {
+				String line = br.readLine();
+				hostTable[i] = line;
+				i++;
+			}
+			localhost = InetAddress.getLocalHost().getHostName();
+			for (int j=0; j<hostTable.length; j++) {
+				if(localhost.equals(hostTable[j])){
+					nextHost = hostTable[++j];
+					if(j == ring) {
+						nextHost = hostTable[0];
+					}
+				}
+			}
+			
+			if(localhost.equals(hostTable[0])) {
+				chknum = 1;
+			}
+				
+			System.out.println("localhost:"+localhost);
+			System.out.println("nexthost:"+nextHost);
+		
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e){
+			e.printStackTrace();
+		}
+	}
+	
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/cluster/HostCheck.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,64 @@
+package fdl.old.test.transfer.cluster;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.InetAddress;
+
+public class HostCheck {
+	private static String bufstring;
+	private static String txt;
+	private static Integer ring;
+	private static int bufsize;
+	private static String nextHost;
+	private static int chknum;
+
+	public static void main(String[] args) {
+		String localhost = null;
+		BufferedReader br = null;
+		for (int k=0; k<args.length; ++k) {
+			if("-bufsize".equals(args[k])){
+				bufstring = args[++k];
+			} else if("-ring".equals(args[k])){
+				txt = args[++k];
+				ring = Integer.valueOf(txt);
+			} else {
+	        System.err.println("引数指定の誤り：未知の引数が指定されました");
+            }
+		}
+		String hostTable[] = new String[ring+1];
+		bufsize = Integer.parseInt(bufstring);
+		try {
+			br = new BufferedReader(new FileReader("nodelist"));
+			int i = 0;
+			while (br.ready()) {
+				String line = br.readLine();
+				hostTable[i] = line;
+				i++;
+			}
+			localhost = InetAddress.getLocalHost().getHostName();
+			for (int j=0; j<hostTable.length; j++){
+				if(localhost.equals(hostTable[j])){
+				nextHost = hostTable[++j];
+				if(j == ring) {
+					nextHost = hostTable[0];
+				}
+			}
+			}
+			if(localhost.equals(hostTable[0])) {
+				chknum = 1;
+			}
+			
+			System.out.println("localhost:"+localhost);
+			System.out.println("nexthost:"+nextHost);
+
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e){
+			e.printStackTrace();
+		}
+		ProtocolEngine pe = new ProtocolEngine(localhost, nextHost,chknum, bufsize, txt);
+		pe.start();
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/cluster/MetaProtocolEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,177 @@
+package fdl.old.test.transfer.cluster;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import fdl.MetaEngine;
+import fdl.MetaLinda;
+import fdl.PSXLinda;
+import fdl.PSXReply;
+
+public class MetaProtocolEngine implements MetaEngine {
+	private int id = 10;
+
+	private PSXLinda psxget;
+	MetaLinda fdlmeta;
+	String host;
+	int port = 10000;
+	private PSXLinda psxsend;
+	private int chknum;
+
+	SimpleDateFormat DF = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
+
+	private int bufsize;
+
+	private String time;
+	private long timelong;
+	private String start;
+	private String txt;
+	private String transfer;
+	private long transferlong;
+
+	public MetaProtocolEngine(MetaLinda ml, String host, int chknum, int bufsize, String txt) {
+		this.host = host;
+		this.fdlmeta = ml;
+		this.chknum = chknum;
+		this.bufsize = bufsize;
+		this.txt = txt;
+	}
+
+	public void mainLoop(MetaLinda ml){
+		psxget = fdlmeta;
+		if (chknum == 1) {
+			try {
+				sendData();
+				start = DF.format(new Date());
+				System.out.println("Start Time => "+start);
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+		boolean connect = true;
+		while(connect){
+			try {
+				initConnect();
+				transfer = DF.format(new Date());
+				transferlong = new Date().getTime();
+				System.out.println("transfer Time => "+transfer);
+				for(int l = 0; l < 1000; l++) {
+					transfer();
+				}
+				dataChk();
+				write();
+				connect = false;
+			} catch (IOException e) {
+				try {
+					Thread.sleep(40);
+				} catch (InterruptedException e1) {
+				}
+			}
+		}
+	}
+
+	private void initConnect(){
+		boolean connectpsx = true;
+		while(connectpsx){
+			try {
+				psxsend = fdlmeta.open(host, port);
+				connectpsx = false;
+			} catch (IOException e) {
+				try {
+					Thread.sleep(40);
+				} catch (InterruptedException e1) {
+					e1.printStackTrace();
+				}
+			}
+		}
+	}
+
+	private void sendData() throws IOException{
+		boolean connectSend = true;
+		ByteBuffer send = ByteBuffer.allocate(bufsize);
+		byte[] fdata = new byte[bufsize];
+		//		fdata = InetAddress.getLocalHost().getAddress();
+		for(int n=0; n < fdata.length; n++ ){
+			fdata[n] = 1;
+		}
+		send.put(fdata);
+		send.flip();
+		while(connectSend){
+			psxget.out(id, send);
+			psxget.sync(1);
+			System.out.println("Send Data");
+			connectSend = false;
+		}
+	}
+
+	public void transfer() throws IOException {
+		ByteBuffer data = ByteBuffer.allocate(bufsize);
+		boolean running = true;
+		PSXReply in = psxget.in(id);
+		while (running) {
+			if(in.ready()){
+				data = in.getData();
+				psxsend.out(id,data);
+				System.out.println("connect to => "+host);
+				psxsend.sync(1);
+				running = false;
+				break;
+			}
+			fdlmeta.sync(0);
+		}
+	}
+
+	public void dataChk() throws IOException{
+		fdlmeta.sync(1);
+		boolean running2 = true;
+		//		ByteBuffer data2 = ByteBuffer.allocate(bufsize);
+		PSXReply in2 = psxget.in(id);
+		//		byte[] fdata2 = new byte[bufsize];
+		//		byte[] fdata3 = new byte[bufsize];
+		//		fdata = InetAddress.getLocalHost().getAddress();
+		//		for(int n=0; n < fdata2.length; n++ ){
+		//			fdata2[n] = 1;
+		//		}
+		while (running2) {
+			psxget.sync(1);
+			if(in2.ready()) {
+				//				data2 = in2.getData();
+				//				data2.get(fdata3);
+				//				if (fdata2 == fdata3){
+				time = DF.format(new Date());
+				timelong = new Date().getTime();
+				System.out.println("Around Time => "+time);
+				//				}
+				running2 = false;
+				break;
+			}
+		}
+	}
+
+
+	public void write() throws IOException{
+		long result = (timelong - transferlong);
+		String diff = String.valueOf(result);
+		File read = new File("resultTime"+bufsize+"_"+txt+".txt");
+		read.createNewFile();
+		FileWriter filewrite = new FileWriter(read);
+		if (start != "null"){
+			filewrite.write("ServerStart => "+start+"\r\n");
+		}
+		if (transfer != "null") {
+			filewrite.write("TransferTime => "+transfer+"\r\n");
+		}
+		if (time != "null"){
+			filewrite.write("AroundTime => "+time+"\r\n");
+		}
+		if (diff != "null"){
+			filewrite.write("DiffTime => "+diff+"\r\n");
+		}
+		filewrite.close();
+	}
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/fdl/old/test/transfer/cluster/ProtocolEngine.java	Wed Feb 08 18:02:40 2012 +0900
@@ -0,0 +1,147 @@
+package fdl.old.test.transfer.cluster;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.nio.ByteBuffer;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import fdl.FederatedLinda;
+import fdl.PSXLinda;
+import fdl.PSXReply;
+
+
+public class ProtocolEngine extends Thread{
+	static int id = 10;
+	static FederatedLinda fdl;
+	static PSXLinda getpsx;
+	static PSXLinda sendpsx;
+	static int port = 10000;
+	String getHost = null;
+	String sendHost = null;
+	private int chknum;
+	private int bufsize;
+	private String txt;
+	SimpleDateFormat DF = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
+	private String time;
+	private long timelong;
+	private String start;
+	private String transfer;
+	private long transferlong;
+	
+	public ProtocolEngine(String gethost, String sendhost, int chknum, int bufsize, String txt) {
+		this.getHost = gethost;
+		this.sendHost = sendhost;
+		this.chknum = chknum;
+		this.bufsize = bufsize;
+		this.txt = txt;
+	}
+
+	public void run(){
+		fdl = FederatedLinda.init();
+		try {
+			getpsx = fdl.open(getHost,port);
+			System.out.println("Connect Host1");
+			sendpsx = fdl.open(sendHost,port);
+			System.out.println("Connect Host2");
+			// Host1にデータを送信する。
+			if(chknum == 1){
+			testSend(getpsx);
+			start = DF.format(new Date());
+			System.out.println("Start Time => "+start);
+			}
+			// psxにデータを用意
+			transfer(getpsx,sendpsx);
+			dataChk();
+			write();
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private void write() throws IOException {
+		long result = (timelong - transferlong);
+		String diff = String.valueOf(result);
+		File read = new File("resultTime"+bufsize+"_"+txt+".txt");
+		read.createNewFile();
+		FileWriter filewrite = new FileWriter(read);
+		if (start != "null"){
+		filewrite.write("ServerStart => "+start+"\r\n");
+		}
+		if (transfer != "null") {
+		filewrite.write("TransferTime => "+transfer+"\r\n");
+		}
+		if (time != "null"){
+		filewrite.write("AroundTime => "+time+"\r\n");
+		}
+		if (diff != "null"){
+		filewrite.write("DiffTime => "+diff+"\r\n");
+		}
+		filewrite.close();
+	}
+
+	private void dataChk() throws IOException {
+		fdl.sync(1);
+		boolean running2 = true;
+		ByteBuffer data3 = ByteBuffer.allocate(bufsize);
+		PSXReply in2 = getpsx.in(id);
+		int localhost2 = InetAddress.getLocalHost().hashCode();
+		while (running2) {
+			getpsx.sync(1);
+			if(in2.ready()) {
+			data3 = in2.getData();
+			int i = data3.getInt();
+			if (i == localhost2){
+				time = DF.format(new Date());
+				timelong = new Date().getTime();
+				System.out.println("Around Time => "+time);
+			}
+			running2 = false;
+			break;
+			}
+		}
+		
+	}
+
+	private void testSend(PSXLinda psx2) throws IOException {
+		boolean connectSend = true;
+		ByteBuffer send = ByteBuffer.allocate(bufsize);
+		int localhost = InetAddress.getLocalHost().hashCode();
+		send.putInt(localhost);
+		send.flip();
+		while(connectSend){
+		psx2.out(id, send);
+		psx2.sync(1);
+		System.out.println("Send Data");
+		connectSend = false;
+		}
+	}
+	
+
+	private void transfer(PSXLinda getpsx, PSXLinda sendpsx) throws IOException {
+		ByteBuffer data2 = ByteBuffer.allocate(bufsize);
+		PSXReply in = getpsx.in(id);
+		boolean running = true;
+		while (running) {
+			if(in.ready()){
+				//psx1にデータを書き出し
+				data2 = in.getData();
+				sendpsx.out(id,data2);
+				//runningフラグをfalseする
+				running = false;
+				transfer = DF.format(new Date());
+				transferlong = new Date().getTime();
+				System.out.println("transfer Time => "+transfer);
+				System.out.println("connect to => "+sendHost);
+				sendpsx.sync(1);
+				break;
+			}
+			fdl.sync();
+		}
+		
+	}
+
+}