import SocketServer
import socket
import string

import time

import java.lang.System as System
 
from SocketServer import ThreadingMixIn, TCPServer, StreamRequestHandler


class Server(StreamRequestHandler):
     
    def handle(self):
        while True:
            try:
                data = self.rfile.readline().strip()
            except:
                print '\nIn Server handle()',
                print ' - Exception - connection closed?'
                break
            if not string.strip(data):
                break
            
            print 'Data received ', data
            
            self.wfile.write("Ready" + "\r\n")
        
        self.rfile.close()

        
class RemoteServer(ThreadingMixIn, TCPServer):
    allow_reuse_address = True

if __name__ == "__main__":   

    remoteCommandPort = 9000

    serveraddr = ('', remoteCommandPort)
    try:
        srvr = RemoteServer(serveraddr, Server)
    except:
        print '\nIn RemoteServer - Could not bind to port'
        sys.exit(1)
        
    print '\nRemote Server Ready on port: %d' % remoteCommandPort
    srvr.serve_forever()

##
##
##
# Tests RemoteConnection directly

import javax.swing as swing
import java.awt as awt

from Client import Client

import sys


class TestRemoteConnectionGUI(swing.JFrame):
    def __init__(self, 
                 remoteConnectionHost, 
                 remoteConnectionPort = 9000):
        
        self.remoteConnectionHost = remoteConnectionHost
        self.remoteConnectionPort = remoteConnectionPort 
        
        swing.JFrame.__init__(self, title='Test Send Connection GUI', 
                              size =(350, 150), windowClosing=self.onCloseWindow)
        self.layout = awt.FlowLayout()
        
        self.sendButton = swing.JButton("Send", size=(65, 70), actionPerformed=self.onSend)
        self.sendButton.setEnabled(True)
        self.add(self.sendButton)
        
        self.client = Client(self.remoteConnectionHost, self.remoteConnectionPort, self)
 
    def onSend(self, event):
        self.disableAllButtons()
        self.client.send()
        
    def readyReceived(self):
        self.sendButton.setEnabled(True)
        print '\nIn ClientGUI readyReceived()'
        
    def disableAllButtons(self):
        self.sendButton.setEnabled(False)

    def onCloseWindow(self, event):
        self.client.disconnect()
        self.client.fc.close()
        self.client.fc = None
        sys.exit(0)
        
if __name__ == "__main__":
    
    print '\n\nClientGUI' 
    TestRemoteConnectionGUI('localhost').setVisible(True)
#
#
#
import sys
import socket
import threading

class Client:
    def __init__(self, remoteAddress, remotePort, callback):
        self.callback = callback
        self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        #self.connection.settimeout(0.0)
        try:
            self.connection.connect((remoteAddress, remotePort))
            self.fc = self.connection.makefile('rw', 0)
        except socket.error, e:
            print 'Connection error: %s' %e
            print 'Could not connect'
            sys.exit(1)
        
        

        self.incomingMessageHandler = IncomingMessageHandler(self.fc, self)
        
    def send(self):
        print 'In Client send()'
        self.fc.write("Send" + "\r\n")
        
    def readyReceived(self):
        print 'In Client readyReceived()'
        self.callback.readyReceived()
        
    def disconnect(self):
        print 'In Client disconnect()'
        if self.incomingMessageHandler.isAlive():
            self.running = False
            print 'In Client disconnect - after incomingMessageHandler running set to False'
            #self.incomingMessageHandler.join()
        
            del self.incomingMessageHandler    
            print 'In Client disconnect() - after del incomingMessageHandler'
        


class IncomingMessageHandler(threading.Thread):
    def __init__(self, inputStream, client):
        threading.Thread.__init__(self)
        self.inputStream = inputStream
        self.client = client
        self.running = True
        self.start()
        
    def run(self):
        while self.running:
            try:
                message = self.inputStream.readline().strip()
                if not message:
                    break
                if message.startswith('Ready'):
                    print 'In IncomingMessageHandler run() receiving Ready: ', message
                    self.client.readyReceived()
                else:
                    print 'Unhandled message', message
            except socket.timeout:
                print "timeout"
            except socket.error:
                print '\nIn IncomingMessageHandler socket error'
                break
                
        print '\nIncoming message handler - exiting thread'