def convProgress(socket):
	socket.listen(0)
	conn, addr = socket.accept()
	while 1:
		data = conn.recv(4096)
		if not data: break
		print data,
	sys.stderr.write("Progress thread exiting!!")
	socket.close()

 def accept(self):
     """Accepts a new connection from a remote client, and returns
     a tuple containing that new connection wrapped with a server-side
     SSL channel, and the address of the remote client."""
     newsock, addr = socket.accept(self)
     try:
         return (SSLSocket(newsock, keyfile=self.keyfile, certfile=self.certfile, server_side=True, cert_reqs=self.cert_reqs, ssl_version=self.ssl_version, ca_certs=self.ca_certs, ciphers=self.ciphers, do_handshake_on_connect=self.do_handshake_on_connect, suppress_ragged_eofs=self.suppress_ragged_eofs), addr)
     except socket_error as e:
         newsock.close()
         raise e

    def accept(self):
        """Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client."""

        newsock, addr = socket.accept(self)
        newsock = self.context.wrap_socket(newsock,
                    do_handshake_on_connect=self.do_handshake_on_connect,
                    suppress_ragged_eofs=self.suppress_ragged_eofs,
                    server_side=True)
        return newsock, addr

    def accept(self):

        """Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client."""

        newsock, addr = socket.accept(self)
        return (SSLSocket(newsock,
                          keyfile=self.keyfile,
                          certfile=self.certfile),
                addr)

    def accept(self):
        """
        Accepts a new connection from a remote client, and returns a tuple
        containing that new connection wrapped with a server-side secure
        channel, and the address of the remote client.
        """
        if not self.server_side:
            raise ValueError("can't accept in client-side mode")

        newsock, addr = socket.accept(self)
        newsock = self.context.wrap_socket(
            newsock,
            do_handshake_on_connect=self.do_handshake_on_connect,
            suppress_ragged_eofs=self.suppress_ragged_eofs,
            server_side=True)

        return newsock, addr

 def accept(self):
     (newsock, addr) = socket.accept(self)
     newsock = self.context.wrap_socket(newsock, do_handshake_on_connect=self.do_handshake_on_connect, suppress_ragged_eofs=self.suppress_ragged_eofs, server_side=True)
     return (newsock, addr)

 def accept(self):
     newsock, addr = socket.accept(self)
     return (SSLSocket(newsock, keyfile=self.keyfile, certfile=self.certfile, server_side=True, cert_reqs=self.cert_reqs, ssl_version=self.ssl_version, ca_certs=self.ca_certs, ciphers=self.ciphers, do_handshake_on_connect=self.do_handshake_on_connect, suppress_ragged_eofs=self.suppress_ragged_eofs), addr)

from django.conf import settings
from utils import sendMsg, recvMsg, abnormalShutdown
def server_port():
    return 12322

if __name__ == "__main__":
    # Create socket object
    socket = socket(AF_INET, SOCK_STREAM)
    # Bind socket to localhost on defined port
    socket.bind(('', server_port()))
    # Start listening
    socket.listen(0)
    
    while True:
        # Accept connections while server is alive
        conn, address = socket.accept()
        
        # Print connection information
        #print("Connection received from client address " + str(address[0]) + " on port " + str(address[1]))
        
        # Try to receive incoming message and starting time
        incomingMsg = recvMsg(conn)
        # Print message from client
        #print("Received from client: " + str(incomingMsg))

        ser = serial.Serial(settings.TTY_PORT, '9600', timeout=5)
        time.sleep(2)

        try:
            ser.write(str(incomingMsg))
        except: